using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Splatform;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("SullysAutoPinner")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SullysAutoPinner")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("53eb7460-cf9b-4412-b6f9-0c7191329f58")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.2.0.0")]
[BepInPlugin("sullys.autopinner", "Sullys Auto Pinner", "1.2.7")]
public class SullysAutoPinner : BaseUnityPlugin
{
private PinSettings _settings;
private PinManager _pinManager;
private ConfigLoader _configLoader;
private PinScanner _scanner;
private PrefabTracker _prefabTracker;
private float _lastScanTime;
private void Awake()
{
_configLoader = new ConfigLoader(((BaseUnityPlugin)this).Logger);
_settings = _configLoader.Load();
_pinManager = new PinManager(_settings, ((BaseUnityPlugin)this).Logger);
_prefabTracker = new PrefabTracker(((BaseUnityPlugin)this).Logger, _settings);
_scanner = new PinScanner(_settings, _pinManager, _prefabTracker);
_configLoader.EnableHotReload(delegate
{
_settings = _configLoader.Load();
_scanner = new PinScanner(_settings, _pinManager, _prefabTracker);
_lastScanTime = 0f;
if (_settings.ClearAllMapPinsAndHistory)
{
_pinManager.RemoveAllPins();
_settings.ClearAllMapPinsAndHistory = false;
_configLoader.SaveDefault(_settings);
((BaseUnityPlugin)this).Logger.LogWarning((object)"[SullysAutoPinner] All map pins cleared and config flag reset.");
}
if (_settings.ClearAllUnwantedPins)
{
_pinManager.RemoveUnwantedPins(_settings);
_settings.ClearAllUnwantedPins = false;
_configLoader.SaveDefault(_settings);
((BaseUnityPlugin)this).Logger.LogWarning((object)"[SullysAutoPinner] Unwanted pins cleared and config flag reset.");
}
((BaseUnityPlugin)this).Logger.LogWarning((object)"[SullysAutoPinner] Config hot-reloaded — scanner reset.");
});
((BaseUnityPlugin)this).Logger.LogWarning((object)"SullysAutoPinner Initialized");
}
private void Update()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)Player.m_localPlayer == (Object)null))
{
if (Time.time - _lastScanTime > _settings.ScanInterval)
{
_lastScanTime = Time.time;
_scanner.RunScan(((Component)Player.m_localPlayer).transform.position);
}
_pinManager.TryPeriodicSave();
_prefabTracker.TryPeriodicSave();
}
}
private void OnApplicationQuit()
{
_pinManager.SaveImmediate();
_prefabTracker.SaveImmediate();
}
}
public class ConfigLoader
{
private static readonly string SaveFolder = Path.Combine(Paths.ConfigPath, "SullysAutoPinnerFiles");
private static readonly string ConfigFilePath = Path.Combine(SaveFolder, "SullysAutoPinner.cfg");
private readonly ManualLogSource _logger;
private FileSystemWatcher _watcher;
private Timer _debounceTimer;
private Action _onReload;
public ConfigLoader(ManualLogSource logger)
{
_logger = logger;
Directory.CreateDirectory(SaveFolder);
}
public void EnableHotReload(Action onReload)
{
_onReload = onReload;
_watcher = new FileSystemWatcher(SaveFolder, "SullysAutoPinner.cfg")
{
NotifyFilter = (NotifyFilters.Size | NotifyFilters.LastWrite)
};
_watcher.Changed += OnConfigChanged;
_watcher.Renamed += OnConfigChanged;
_watcher.EnableRaisingEvents = true;
_logger.LogWarning((object)"[ConfigLoader] Hot config reload enabled.");
}
private void OnConfigChanged(object sender, FileSystemEventArgs e)
{
_debounceTimer?.Dispose();
_debounceTimer = new Timer(delegate
{
try
{
_logger.LogWarning((object)"[ConfigLoader] Config file updated — reloading.");
_onReload?.Invoke();
}
catch (Exception ex)
{
_logger.LogWarning((object)("[ConfigLoader] Reload failed: " + ex.Message));
}
}, null, 200, -1);
}
public PinSettings Load()
{
PinSettings pinSettings = new PinSettings();
Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
if (File.Exists(ConfigFilePath))
{
string[] array = File.ReadAllLines(ConfigFilePath);
for (int i = 0; i < array.Length; i++)
{
string text = array[i].Trim();
if (!text.StartsWith("#") && text.Contains("="))
{
string[] array2 = text.Split(new char[1] { '=' }, 2);
dictionary[array2[0].Trim().ToLowerInvariant()] = array2[1].Trim().ToLowerInvariant();
}
}
foreach (KeyValuePair<string, string> item in dictionary)
{
ApplyKeyValue(pinSettings, item.Key, item.Value);
}
List<string> list = (from f in typeof(PinSettings).GetFields()
where f.FieldType == typeof(bool)
select f.Name.ToLowerInvariant()).ToHashSet().Except(dictionary.Keys).ToList();
array = new string[2] { "clearallmappinsandhistory", "clearallunwantedpins" };
foreach (string text2 in array)
{
if (!dictionary.ContainsKey(text2) && !list.Contains(text2))
{
list.Add(text2);
}
}
if (list.Any())
{
AppendMissingDefaults(pinSettings, list);
}
}
else
{
SaveDefault(pinSettings);
}
return pinSettings;
}
private void ApplyKeyValue(PinSettings settings, string key, string value)
{
bool flag = value.Equals("true", StringComparison.OrdinalIgnoreCase);
float result;
switch (key)
{
case "scanradius":
if (float.TryParse(value, out result))
{
settings.ScanRadius = result;
}
return;
case "scaninterval":
if (float.TryParse(value, out result))
{
settings.ScanInterval = result;
}
return;
case "saveinterval":
if (float.TryParse(value, out result))
{
settings.SaveInterval = result;
}
return;
case "pinmergedistance":
if (float.TryParse(value, out result))
{
settings.PinMergeDistance = result;
}
return;
}
FieldInfo fieldInfo = typeof(PinSettings).GetFields().FirstOrDefault((FieldInfo f) => f.Name.Equals(key, StringComparison.OrdinalIgnoreCase));
if (fieldInfo != null && fieldInfo.FieldType == typeof(bool))
{
fieldInfo.SetValue(settings, flag);
}
}
private void AppendMissingDefaults(PinSettings settings, IEnumerable<string> missingKeys)
{
try
{
using (StreamWriter streamWriter = File.AppendText(ConfigFilePath))
{
foreach (string key in missingKeys)
{
bool flag = (bool)typeof(PinSettings).GetFields().First((FieldInfo f) => f.Name.Equals(key, StringComparison.InvariantCultureIgnoreCase)).GetValue(settings);
streamWriter.WriteLine(key + "=" + flag.ToString().ToLowerInvariant());
}
}
_logger.LogWarning((object)("Appended missing config keys to: " + ConfigFilePath));
}
catch (Exception ex)
{
_logger.LogWarning((object)("Error appending missing defaults: " + ex.Message));
}
}
public void SaveDefault(PinSettings settings)
{
try
{
using (StreamWriter streamWriter = new StreamWriter(ConfigFilePath))
{
streamWriter.WriteLine("# SullysAutoPinner config");
streamWriter.WriteLine("scanradius=" + settings.ScanRadius);
streamWriter.WriteLine("scaninterval=" + settings.ScanInterval);
streamWriter.WriteLine("saveinterval=" + settings.SaveInterval);
streamWriter.WriteLine("pinmergedistance=" + settings.PinMergeDistance);
FieldInfo[] fields = typeof(PinSettings).GetFields();
foreach (FieldInfo fieldInfo in fields)
{
if (fieldInfo.FieldType == typeof(bool))
{
string text = fieldInfo.Name.ToLowerInvariant();
streamWriter.WriteLine(text + "=" + ((bool)fieldInfo.GetValue(settings)).ToString().ToLowerInvariant());
}
}
}
_logger.LogWarning((object)("Default config created at: " + ConfigFilePath));
}
catch (Exception ex)
{
_logger.LogWarning((object)("Error saving default config: " + ex.Message));
}
}
}
public class PinSettings
{
public float ScanRadius = 300f;
public float ScanInterval = 12f;
public float SaveInterval = 120f;
public float PinMergeDistance = 50f;
public bool EnablePinSaving = true;
public bool EnablePrefabLogging;
public bool Mushrooms;
public bool RaspBerries;
public bool BlueBerries;
public bool Seeds;
public bool Thistle;
public bool CloudBerries;
public bool Copper = true;
public bool Tin;
public bool Skeleton;
public bool DwarfSpawner = true;
public bool TrollCave = true;
public bool Crypt = true;
public bool Totem = true;
public bool DraugrSpawner;
public bool Treasure;
public bool Barley;
public bool Flax;
public bool Tar = true;
public bool DragonEgg = true;
public bool VoltureEgg = true;
public bool SmokePuffs;
public bool MageCaps;
public bool YPCones = true;
public bool JotunnPuffs;
public bool Iron = true;
public bool Meteorite = true;
public bool Obsidian = true;
public bool Silver = true;
public bool MistlandsGiants = true;
public bool MistlandsSwords = true;
public bool DvergerThings = true;
public bool ClearAllMapPinsAndHistory;
public bool ClearAllUnwantedPins;
}
public class PinManager
{
private const int PinFlushThreshold = 250;
private readonly List<Tuple<Vector3, string>> _pinQueue = new List<Tuple<Vector3, string>>();
private readonly HashSet<string> _pinHashes = new HashSet<string>();
private readonly PinSettings _settings;
private readonly ManualLogSource _logger;
private float _lastSaveTime;
private static readonly string SaveFolder = Path.Combine(Paths.ConfigPath, "SullysAutoPinnerFiles");
private static readonly string PinsFilePath = Path.Combine(SaveFolder, "Pins.txt");
public PinManager(PinSettings settings, ManualLogSource logger)
{
_settings = settings;
_logger = logger;
Directory.CreateDirectory(Path.GetDirectoryName(PinsFilePath));
LoadPinsFromFile();
}
public void TryAddPin(Vector3 pos, string label)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: 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_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Minimap.instance == (Object)null)
{
return;
}
Vector3 val = RoundTo0_1(pos);
string pinHash = GetPinHash(val, label);
if (_pinHashes.Contains(pinHash))
{
return;
}
foreach (Tuple<Vector3, string> item in _pinQueue)
{
if (Vector3.Distance(item.Item1, val) < _settings.PinMergeDistance && string.Equals(item.Item2, label, StringComparison.OrdinalIgnoreCase))
{
return;
}
}
Minimap.instance.AddPin(val, (PinType)3, label, true, false, 0L, default(PlatformUserID));
_pinQueue.Add(new Tuple<Vector3, string>(val, label));
_pinHashes.Add(pinHash);
if (_settings.EnablePinSaving && _pinQueue.Count >= 250)
{
SavePinsToFile();
}
}
public void TryPeriodicSave()
{
if (_settings.EnablePinSaving && _pinQueue.Count != 0 && Time.time - _lastSaveTime > _settings.SaveInterval)
{
SavePinsToFile();
}
}
public void SaveImmediate()
{
if (_settings.EnablePinSaving && _pinQueue.Count > 0)
{
SavePinsToFile();
}
}
public void RemoveAllPins()
{
if ((Object)(object)Minimap.instance == (Object)null)
{
return;
}
_pinHashes.Clear();
_pinQueue.Clear();
try
{
File.WriteAllText(PinsFilePath, string.Empty);
_logger.LogWarning((object)"SullysAutoPinner >>> All Map Pins Removed -Pin history file emptied.");
}
catch (Exception ex)
{
_logger.LogWarning((object)("SullysAutoPinner >>> All Map Pins Removed - Failed to clear Pins.txt: " + ex.Message));
return;
}
if (!(AccessTools.Field(typeof(Minimap), "m_pins").GetValue(Minimap.instance) is List<PinData> list))
{
return;
}
foreach (PinData item in list.ToList())
{
Minimap.instance.RemovePin(item);
}
_logger.LogWarning((object)$"SullysAutoPinner >>> All Map Pins Removed {list.Count} pins from the map.");
}
public void RemoveUnwantedPins(PinSettings settings)
{
if ((Object)(object)Minimap.instance == (Object)null)
{
return;
}
List<PinData> obj = AccessTools.Field(typeof(Minimap), "m_pins").GetValue(Minimap.instance) as List<PinData>;
List<PinData> list = new List<PinData>();
foreach (PinData item in obj)
{
string label = item.m_name.ToUpperInvariant();
if (!IsLabelEnabled(label, settings))
{
list.Add(item);
}
}
foreach (PinData item2 in list)
{
Minimap.instance.RemovePin(item2);
}
_logger.LogWarning((object)$"Removed {list.Count} unwanted pins from the map.");
}
private bool IsLabelEnabled(string label, PinSettings settings)
{
switch (label)
{
case "CRYPT":
return settings.Crypt;
case "TROLLCAVE":
return settings.TrollCave;
case "COPPER":
return settings.Copper;
case "IRON":
return settings.Iron;
case "TIN":
return settings.Tin;
case "OBSIDIAN":
return settings.Obsidian;
case "SILVER":
return settings.Silver;
case "METEOR":
return settings.Meteorite;
case "TAR":
return settings.Tar;
case "FLAX":
return settings.Flax;
case "BARLEY":
return settings.Barley;
case "BLUE":
return settings.BlueBerries;
case "BERRIES":
return settings.RaspBerries;
case "SHROOMS":
return settings.Mushrooms;
case "CLOUD":
return settings.CloudBerries;
case "THISTLE":
return settings.Thistle;
case "ONION":
case "TURNIP":
case "CARROT":
return settings.Seeds;
case "MAGECAP":
return settings.MageCaps;
case "Y-PCONE":
return settings.YPCones;
case "J-PUFF":
return settings.JotunnPuffs;
case "V-EGG":
return settings.VoltureEgg;
case "DRAGONEGG":
return settings.DragonEgg;
case "SMOKEPUFF":
return settings.SmokePuffs;
case "THING":
return settings.DvergerThings;
case "DWARFSPAWNER":
return settings.DwarfSpawner;
case "DRAUGRSPAWNER":
return settings.DraugrSpawner;
case "TOTEM":
return settings.Totem;
case "SKEL":
return settings.Skeleton;
case "BOX":
return settings.Treasure;
case "SWORDS":
return settings.MistlandsSwords;
case "GIANT":
return settings.MistlandsGiants;
default:
return true;
}
}
private void SavePinsToFile()
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
try
{
using StreamWriter streamWriter = File.AppendText(PinsFilePath);
foreach (Tuple<Vector3, string> item in _pinQueue)
{
streamWriter.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:F1}|{1:F1}|{2:F1}|{3}", item.Item1.x, item.Item1.y, item.Item1.z, item.Item2));
}
}
catch (Exception ex)
{
_logger.LogWarning((object)("SullyAutoPinner >>> Error saving pins: " + ex.Message));
}
_pinQueue.Clear();
_lastSaveTime = Time.time;
}
private void LoadPinsFromFile()
{
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!File.Exists(PinsFilePath))
{
return;
}
string[] array = File.ReadAllLines(PinsFilePath);
Vector3 pos = default(Vector3);
for (int i = 0; i < array.Length; i++)
{
string[] array2 = array[i].Split(new char[1] { '|' });
if (array2.Length == 4 && float.TryParse(array2[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array2[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
{
string label = array2[3];
((Vector3)(ref pos))..ctor(result, result2, result3);
string pinHash = GetPinHash(pos, label);
_pinHashes.Add(pinHash);
}
}
}
catch (Exception ex)
{
_logger.LogWarning((object)("SullyAutoPinner >>> Error loading pins: " + ex.Message));
}
}
private string GetPinHash(Vector3 pos, string label)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: 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)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = RoundTo0_1(pos);
return string.Format(CultureInfo.InvariantCulture, "{0}:{1:F1},{2:F1},{3:F1}", label.ToUpperInvariant(), val.x, val.y, val.z);
}
private Vector3 RoundTo0_1(Vector3 v)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
return new Vector3(Mathf.Round(v.x * 10f) / 10f, Mathf.Round(v.y * 10f) / 10f, Mathf.Round(v.z * 10f) / 10f);
}
}
public class PrefabTracker
{
private readonly HashSet<string> _seenPrefabs = new HashSet<string>();
private readonly ManualLogSource _logger;
private readonly PinSettings _settings;
private float _lastPrefabDumpTime;
private const float DumpInterval = 300f;
private const int PrefabFlushThreshold = 1000;
private const string PrefabsFilePath = "BepInEx/config/SullysAutoPinnerFiles/SeenPrefabs.txt";
private static readonly HashSet<string> IgnoredPrefabs = new HashSet<string> { "tree", "bush", "log", "stone", "branch" };
public PrefabTracker(ManualLogSource logger, PinSettings settings)
{
_logger = logger;
_settings = settings;
Directory.CreateDirectory(Path.GetDirectoryName("BepInEx/config/SullysAutoPinnerFiles/SeenPrefabs.txt"));
}
public void LogPrefabHierarchy(GameObject rootGO)
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Expected O, but got Unknown
if (!_settings.EnablePrefabLogging || (Object)(object)rootGO == (Object)null)
{
return;
}
string text = ((Object)rootGO).name.ToLowerInvariant();
foreach (string ignoredPrefab in IgnoredPrefabs)
{
if (text.Contains(ignoredPrefab))
{
return;
}
}
List<string> list = new List<string>();
foreach (Transform item2 in rootGO.transform)
{
Transform val = item2;
if ((Object)(object)val != (Object)null)
{
list.Add(((Object)val).name);
}
}
list.Sort();
string item = ((Object)rootGO).name + " | " + string.Join(",", list);
if (_seenPrefabs.Add(item) && _seenPrefabs.Count >= 1000)
{
SaveImmediate();
}
}
public void TryPeriodicSave()
{
if (_settings.EnablePrefabLogging && Time.time - _lastPrefabDumpTime > 300f)
{
SaveImmediate();
}
}
public void SaveImmediate()
{
_lastPrefabDumpTime = Time.time;
try
{
HashSet<string> hashSet = new HashSet<string>();
if (File.Exists("BepInEx/config/SullysAutoPinnerFiles/SeenPrefabs.txt"))
{
string[] array = File.ReadAllLines("BepInEx/config/SullysAutoPinnerFiles/SeenPrefabs.txt");
foreach (string item in array)
{
hashSet.Add(item);
}
}
using StreamWriter streamWriter = File.AppendText("BepInEx/config/SullysAutoPinnerFiles/SeenPrefabs.txt");
foreach (string seenPrefab in _seenPrefabs)
{
if (!hashSet.Contains(seenPrefab))
{
streamWriter.WriteLine(seenPrefab);
}
}
}
catch (Exception ex)
{
_logger.LogWarning((object)("SullyAutoPinner >>> Error saving prefab list: " + ex.Message));
}
}
}
public class PinScanner
{
private readonly PinSettings _settings;
private readonly PinManager _pinManager;
private readonly PrefabTracker _prefabTracker;
public PinScanner(PinSettings settings, PinManager pinManager, PrefabTracker prefabTracker)
{
_settings = settings;
_pinManager = pinManager;
_prefabTracker = prefabTracker;
}
public void RunScan(Vector3 playerPosition)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
Collider[] array = Physics.OverlapSphere(playerPosition, _settings.ScanRadius, -1, (QueryTriggerInteraction)2);
for (int i = 0; i < array.Length; i++)
{
GameObject gameObject = ((Component)((Component)array[i]).transform.root).gameObject;
if (!((Object)(object)gameObject == (Object)null))
{
_prefabTracker.LogPrefabHierarchy(gameObject);
string text = ((Object)gameObject).name.ToLowerInvariant();
string label;
if (text.Contains("locationproxy"))
{
HandleLocationProxyChildren(gameObject);
}
else if (TryMatchPrefab(text, out label))
{
_pinManager.TryAddPin(gameObject.transform.position, label);
}
}
}
}
private void HandleLocationProxyChildren(GameObject root)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
//IL_007d: 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_00d5: Expected O, but got Unknown
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
string[] array = new string[2] { "trollcave", "crypt" };
foreach (Transform item in root.transform)
{
Transform val = item;
string text = ((Object)val).name.ToLowerInvariant();
if (text.Contains("runestone"))
{
continue;
}
string[] array2 = array;
foreach (string value in array2)
{
if (text.Contains(value))
{
string label = CleanLabel(((Object)val).name);
_pinManager.TryAddPin(root.transform.position, label);
return;
}
}
}
foreach (Transform item2 in root.transform)
{
Transform val2 = item2;
if (!((Object)val2).name.ToLowerInvariant().Contains("runestone"))
{
string label2 = CleanLabel(((Object)val2).name);
_pinManager.TryAddPin(root.transform.position, label2);
break;
}
}
}
private string CleanLabel(string rawName)
{
return Regex.Replace(rawName.Replace("(Clone)", ""), "\\d", "").ToUpperInvariant();
}
private bool TryMatchPrefab(string name, out string label)
{
label = null;
if (name.Contains("copper") && _settings.Copper)
{
label = "COPPER";
}
else if (name.Contains("mudpile") && _settings.Iron)
{
label = "IRON";
}
else if (name.Contains("meteorite") && _settings.Meteorite)
{
label = "METEOR";
}
else if (name.Contains("obsidian") && _settings.Obsidian)
{
label = "OBS";
}
else if (name.Contains("silvervein") && _settings.Silver)
{
label = "SILVER";
}
else if (name.Contains("tin") && _settings.Tin)
{
label = "TIN";
}
else if (name.Contains("spawner_skeleton") && _settings.Skeleton)
{
label = "SKEL";
}
else if (name.Contains("pickable_magecap") && _settings.MageCaps)
{
label = "MAGECAP";
}
else if (name.Contains("pickable_tar") && _settings.Tar)
{
label = "TAR";
}
else if (name.Contains("pickable_flax") && _settings.Flax)
{
label = "FLAX";
}
else if (name.Contains("pickable_barley") && _settings.Barley)
{
label = "BARLEY";
}
else if (name.Contains("pickable_thistle") && _settings.Thistle)
{
label = "THISTLE";
}
else if (name.Contains("pickable_dvergerthing") && _settings.DvergerThings)
{
label = "THING";
}
else if (name.Contains("mistlands_giant") && _settings.MistlandsGiants)
{
label = "GIANT";
}
else if (name.Contains("mistlands_swords") && _settings.MistlandsSwords)
{
label = "SWORDS";
}
else if (name.Contains("pickable_dragonegg") && _settings.DragonEgg)
{
label = "DRAGONEGG";
}
else if (name.Contains("pickable_voltureegg") && _settings.VoltureEgg)
{
label = "V-EGG";
}
else if (name.Contains("pickable_smokepuff") && _settings.SmokePuffs)
{
label = "SMOKEPUFF";
}
else if (name.Contains("pickable_yggdrasilpinecone") && _settings.YPCones)
{
label = "Y-PCONE";
}
else if (name.Contains("pickable_jotunnpuff") && _settings.JotunnPuffs)
{
label = "J-PUFF";
}
else if (name.Contains("rasp") && _settings.RaspBerries)
{
label = "BERRIES";
}
else if (name.Contains("blue") && _settings.BlueBerries)
{
label = "BLUE";
}
else if (name.Contains("mushroom") && _settings.Mushrooms)
{
label = "SHROOMS";
}
else if (name.Contains("cloud") && _settings.CloudBerries)
{
label = "CLOUD";
}
else if (name.Contains("pickable_seedcarrot") && _settings.Seeds)
{
label = "CARROT";
}
else if (name.Contains("pickable_seedonion") && _settings.Seeds)
{
label = "ONION";
}
else if (name.Contains("pickable_seedturnip") && _settings.Seeds)
{
label = "TURNIP";
}
else if (name.Contains("treasurechest") && _settings.Treasure)
{
label = "BOX";
}
else if (name.Contains("spawner_draugrpile") && _settings.DraugrSpawner)
{
label = "DRAUGRSPAWNER";
}
else if (name.Contains("spawner_greydwarfnest") && _settings.DwarfSpawner)
{
label = "DwarfSpawner";
}
else if (name.Contains("goblin_totempole") && _settings.Totem)
{
label = "TOTEM";
}
return label != null;
}
}
