using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ETGGUI;
using Gunfiguration;
using Gungeon;
using MonoMod.RuntimeDetour;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using SGUI;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("ItemTipsMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3c88a2fb9be593e23ea5a411f65742f18f1e0f11")]
[assembly: AssemblyProduct("ItemTipsMod")]
[assembly: AssemblyTitle("ItemTipsMod")]
[assembly: InternalsVisibleTo("ModTests")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ItemTipsMod;
public class AdvancedSynergyCache
{
public AdvancedSynergyEntry[] SourceEntries;
public Dictionary<string, SynergyGroup> SynergyKeyIndex;
public Dictionary<int, List<SynergyGroup>> ItemIndex;
public AdvancedSynergyCache()
: this(ArrayHelper<AdvancedSynergyEntry>.Empty)
{
}
public AdvancedSynergyCache(AdvancedSynergyEntry[] sourceEntries)
{
SourceEntries = sourceEntries;
Build();
}
private void Build()
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Invalid comparison between Unknown and I4
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Invalid comparison between Unknown and I4
SynergyKeyIndex = new Dictionary<string, SynergyGroup>();
ItemIndex = new Dictionary<int, List<SynergyGroup>>();
AdvancedSynergyEntry[] sourceEntries = SourceEntries;
foreach (AdvancedSynergyEntry val in sourceEntries)
{
if (!string.IsNullOrEmpty(val.NameKey) && (int)val.ActivationStatus != 1 && (int)val.ActivationStatus != 2)
{
if (SynergyKeyIndex.TryGetValue(val.NameKey, out var value))
{
value.Entries.Add(val);
continue;
}
SynergyKeyIndex[val.NameKey] = new SynergyGroup(val.NameKey)
{
Entries = { val }
};
}
}
foreach (KeyValuePair<string, SynergyGroup> item in SynergyKeyIndex)
{
_ = item.Key;
SynergyGroup value2 = item.Value;
foreach (AdvancedSynergyEntry entry in value2.Entries)
{
AddSynergyEntries(entry.MandatoryGunIDs, value2);
AddSynergyEntries(entry.MandatoryItemIDs, value2);
AddSynergyEntries(entry.OptionalGunIDs, value2);
AddSynergyEntries(entry.OptionalItemIDs, value2);
}
}
}
private void AddSynergyEntries(List<int> ids, SynergyGroup group)
{
if (ids == null)
{
return;
}
foreach (int id in ids)
{
if (ItemIndex.TryGetValue(id, out var value))
{
if (!value.Contains(group))
{
value.Add(group);
}
}
else
{
ItemIndex[id] = new List<SynergyGroup> { group };
}
}
}
}
public class SynergyGroup
{
public readonly string NameKey;
public List<AdvancedSynergyEntry> Entries = new List<AdvancedSynergyEntry>();
public SynergyGroup(string nameKey)
{
NameKey = nameKey;
}
public bool SynergyIsAvailable(PlayerController p1, PlayerController p2, int additionalID = -1)
{
foreach (AdvancedSynergyEntry entry in Entries)
{
if (entry.SynergyIsAvailable(p1, p2, additionalID))
{
return true;
}
}
return false;
}
}
public sealed class AmmonomiconEntryCache
{
private readonly PickupAndSynergyDataCache _dataCache;
private readonly AdvancedSynergyCache _synergyCache;
private GungeonSupportedLanguages _currentLanguage;
private Dictionary<int, string> _entryCache;
public AmmonomiconEntryCache(AdvancedSynergyCache synergyCache, PickupAndSynergyDataCache dataCache)
{
_synergyCache = synergyCache;
_dataCache = dataCache;
_entryCache = new Dictionary<int, string>();
}
public GungeonSupportedLanguages GetCacheLanguage()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return _currentLanguage;
}
public void SetCacheLanguage(GungeonSupportedLanguages value)
{
//IL_0000: 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_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if (value != _currentLanguage)
{
_entryCache = new Dictionary<int, string>();
_currentLanguage = value;
}
}
public string GetEntry(int pickupId, string origEntry)
{
if (pickupId < 0)
{
return origEntry;
}
if (_entryCache.TryGetValue(pickupId, out var value))
{
return value;
}
if (!_dataCache.Pickups.TryGetValue(pickupId, out var value2))
{
value2 = null;
}
PickupObject byId = PickupObjectDatabase.GetById(pickupId);
string text = GenerateAmmonomiconText(byId, value2);
string text2 = (origEntry + "\n" + text).Trim();
_entryCache[pickupId] = text2;
return text2;
}
private string GenerateAmmonomiconText(PickupObject pickup, ItemData item)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("----------");
TipBuilder.AppendQualityDescriptor(pickup, delegate(string line)
{
builder.AppendLine(line);
});
TipBuilder.AppendActiveCooldownType(pickup, delegate(string line)
{
builder.AppendLine(line);
});
if (item != null)
{
builder.AppendLine(item.Notes);
}
TipBuilder.AppendModifiers(pickup, delegate(StatType stat, string line)
{
builder.AppendLine(line);
});
HashSet<string> hashSet = new HashSet<string>();
if (_synergyCache.ItemIndex.TryGetValue(pickup.PickupObjectId, out var value) && value.Count > 0)
{
builder.AppendLine("Synergies:");
foreach (SynergyGroup item2 in value)
{
string synergyString = StringTableManager.GetSynergyString(item2.NameKey, -1);
if (hashSet.Add(synergyString))
{
string text = (item2.SynergyIsAvailable(GameManager.Instance.PrimaryPlayer, GameManager.Instance.SecondaryPlayer) ? "*" : "");
if (_dataCache.Synergies.TryGetValue(item2.NameKey, out var value2))
{
builder.AppendLine(" - " + text + synergyString + text + ": " + value2.Effect);
}
else
{
builder.AppendLine(" - " + text + synergyString + text);
}
}
}
}
if (item != null && item.Synergies.Length != 0)
{
if (hashSet.Count == 0)
{
builder.AppendLine("Synergies:");
}
SynergyData[] synergies = item.Synergies;
foreach (SynergyData synergyData in synergies)
{
string localizedSynergyName = synergyData.GetLocalizedSynergyName();
if (hashSet.Add(localizedSynergyName))
{
string effect = synergyData.Effect;
string text2 = (synergyData.InternalWouldGetSynergy() ? "*" : "");
if (!string.IsNullOrEmpty(effect))
{
builder.AppendLine(" - " + text2 + localizedSynergyName + text2 + ": " + effect);
}
else
{
builder.AppendLine(" - " + text2 + localizedSynergyName + text2);
}
}
}
}
return builder.ToString();
}
}
internal static class ArrayHelper<T>
{
public static T[] Empty { get; } = new T[0];
}
internal class CooldownLabelBehavior : MonoBehaviour
{
public static CooldownLabelBehavior Instance;
public PlayerCooldownLabelCollection labelCollection;
public bool forceUpdate;
public bool forceInitialize;
public void UpdateLabelPostion()
{
PlayerCooldownLabelData[] cooldownLabelData = labelCollection.cooldownLabelData;
for (int i = 0; i < cooldownLabelData.Length; i++)
{
cooldownLabelData[i].UpdateLabelPostion();
}
}
public void SetVisible(bool visible)
{
labelCollection.ForEach(delegate(PlayerCooldownLabelData c)
{
((dfControl)c.cooldownLabel).IsVisible = visible;
});
}
private void Start()
{
try
{
labelCollection = new PlayerCooldownLabelCollection();
GameManager.Instance.OnNewLevelFullyLoaded += OnNewLevelFullyLoaded;
Instance = this;
}
catch (Exception arg)
{
StaticLogger.LogDebug("Error in CooldownLabelBehavior.Start: {0}", arg);
}
}
private void OnNewLevelFullyLoaded()
{
try
{
labelCollection.Clear();
forceInitialize = true;
forceUpdate = true;
}
catch (Exception arg)
{
StaticLogger.LogDebug("Error in CooldownLabelBehavior.OnNewLevelFullyLoaded: {0}", arg);
}
}
private void Update()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Invalid comparison between Unknown and I4
try
{
if ((int)GameManager.Instance.CurrentLevelOverrideState == 1)
{
return;
}
if (GameManager.Instance.IsLoadingLevel)
{
forceUpdate = true;
forceInitialize = true;
return;
}
if (!GameUIRoot.Instance.IsCoreUIVisible())
{
forceUpdate = true;
return;
}
if (forceInitialize)
{
labelCollection.Initialize(GameManager.Instance.AllPlayers.Length);
forceInitialize = false;
}
for (int i = 0; i < GameManager.Instance.AllPlayers.Length; i++)
{
try
{
PlayerController player = GameManager.Instance.AllPlayers[i];
PlayerCooldownLabelData playerCooldownLabelData = labelCollection[i];
if (playerCooldownLabelData.UpdateBoundState(player) | forceUpdate)
{
forceUpdate = false;
playerCooldownLabelData.UpdateLabelState();
}
}
catch (Exception ex)
{
StaticLogger.LogDebug("Error updating cooldown label for player {0}: {1}", i, ex);
}
}
}
catch (Exception arg)
{
StaticLogger.LogDebug("Error in Cooldown behavior Update: {0}", arg);
}
}
}
internal class PlayerCooldownLabelCollection
{
private static Func<GameUIRoot, int, GameUIItemController> GetPlayerItemController = GetPlayerItemControllerDelegate();
public PlayerCooldownLabelData[] cooldownLabelData;
public PlayerCooldownLabelData this[int index] => cooldownLabelData[index];
public void ForEach(Action<PlayerCooldownLabelData> action)
{
if (cooldownLabelData != null)
{
PlayerCooldownLabelData[] array = cooldownLabelData;
foreach (PlayerCooldownLabelData obj in array)
{
action(obj);
}
}
}
public void Initialize(int playerCount)
{
StaticLogger.LogDebug("Initializing PlayerCooldownLabelCollection, playerCount: {0}", playerCount);
cooldownLabelData = new PlayerCooldownLabelData[playerCount];
for (int i = 0; i < playerCount; i++)
{
PlayerCooldownLabelData playerCooldownLabelData = new PlayerCooldownLabelData
{
itemController = GetPlayerItemController?.Invoke(GameUIRoot.Instance, i)
};
dfLabel val = ((dfControl)((Component)playerCooldownLabelData.itemController).GetComponent<dfPanel>()).AddControl<dfLabel>();
val.TextScale = 2f;
val.AutoSize = true;
((dfControl)val).IsVisible = false;
playerCooldownLabelData.cooldownLabel = val;
if (playerCooldownLabelData.itemController.IsRightAligned)
{
playerCooldownLabelData.BaseRelativeX = 525;
playerCooldownLabelData.BaseRelativeX = 510;
}
else
{
playerCooldownLabelData.BaseRelativeX = 150;
playerCooldownLabelData.BaseRelativeY = 510;
}
playerCooldownLabelData.UpdateLabelPostion();
cooldownLabelData[i] = playerCooldownLabelData;
}
}
public void Clear()
{
if (cooldownLabelData != null)
{
PlayerCooldownLabelData[] array = cooldownLabelData;
for (int i = 0; i < array.Length; i++)
{
array[i].Destroy();
}
cooldownLabelData = null;
}
}
private static Func<GameUIRoot, int, GameUIItemController> GetPlayerItemControllerDelegate()
{
MethodInfo method = typeof(GameUIRoot).GetMethod("GetItemControllerForPlayerID", BindingFlags.Instance | BindingFlags.NonPublic);
if ((object)method != null)
{
Delegate @delegate = Delegate.CreateDelegate(typeof(Func<GameUIRoot, int, GameUIItemController>), method);
Func<GameUIRoot, int, GameUIItemController> f = (Func<GameUIRoot, int, GameUIItemController>)@delegate;
return (GameUIRoot r, int i) => (r?.itemControllers == null) ? null : f(r, i);
}
StaticLogger.LogDebug("Could not find GetItemControllerForPlayerID");
return (GameUIRoot r, int i) => null;
}
}
internal class PlayerCooldownLabelData
{
public GameUIItemController itemController;
public dfLabel cooldownLabel;
public PlayerItem lastItem;
public bool isGhost;
public int BaseRelativeX;
public int BaseRelativeY;
public int AdditionalOffsetPx = 2;
public dfAnchorStyle Anchor = (dfAnchorStyle)6;
public dfPivotPoint Pivot = (dfPivotPoint)6;
public int lastActiveCount = -1;
public float lastCooldown;
public bool showDecimal;
public bool UpdateBoundState(PlayerController player)
{
bool result = false;
if (player.IsGhost != isGhost)
{
isGhost = player.IsGhost;
result = true;
}
if ((Object)(object)player.CurrentItem != (Object)(object)lastItem)
{
lastItem = player.CurrentItem;
result = true;
}
if (Object.op_Implicit((Object)(object)lastItem))
{
showDecimal = false;
float num;
if (lastItem.CurrentRoomCooldown > 0)
{
num = lastItem.CurrentRoomCooldown;
}
else if (lastItem.CurrentDamageCooldown > 0f)
{
num = (int)lastItem.CurrentDamageCooldown;
}
else if (lastItem.CurrentTimeCooldown > 0f)
{
showDecimal = true;
num = lastItem.CurrentTimeCooldown;
}
else
{
num = 0f;
}
if (num != lastCooldown)
{
lastCooldown = num;
result = true;
}
}
if (lastActiveCount != player.activeItems.Count)
{
lastActiveCount = player.activeItems.Count;
result = true;
}
return result;
}
public void UpdateLabelState()
{
if (!Object.op_Implicit((Object)(object)lastItem) || lastCooldown == 0f || isGhost)
{
((dfControl)cooldownLabel).IsVisible = false;
return;
}
((dfControl)cooldownLabel).IsVisible = true;
string text = (showDecimal ? "0.0" : "0");
cooldownLabel.Text = lastCooldown.ToString(text);
UpdateLabelPostion();
}
public void UpdateLabelPostion()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
((dfControl)cooldownLabel).Anchor = Anchor;
((dfControl)cooldownLabel).Pivot = Pivot;
((dfControl)cooldownLabel).RelativePosition = new Vector3((float)BaseRelativeX, (float)BaseRelativeY);
float num = (float)AdditionalOffsetPx * Pixelator.Instance.CurrentTileScale * (float)itemController.AdditionalItemBoxSprites.Count;
if (itemController.IsRightAligned)
{
num = 0f - num;
}
((dfControl)cooldownLabel).RelativePosition = new Vector3((float)BaseRelativeX + num, (float)BaseRelativeY);
}
public void Destroy()
{
if (Object.op_Implicit((Object)(object)cooldownLabel))
{
Object.Destroy((Object)(object)cooldownLabel);
}
}
}
internal static class DebugHelper
{
internal struct ElapsedHelper : IDisposable
{
public readonly string Label;
public readonly long StartTimestamp;
public ElapsedHelper(string label, long startTimestamp)
{
Label = label;
StartTimestamp = startTimestamp;
}
public void Dispose()
{
float num = Stopwatch.GetTimestamp() - StartTimestamp;
if (num <= 0f)
{
StaticLogger.LogDebug(Label + " Elapsed: 0 ms");
return;
}
float num2 = num / (float)Stopwatch.Frequency * 1000f;
StaticLogger.LogDebug($"{Label} Elapsed: {num2} ms");
}
}
public static void AddDebugCommands(ItemTipsModule module)
{
}
public static ElapsedHelper LogElapsed(string label)
{
return new ElapsedHelper(label, Stopwatch.GetTimestamp());
}
}
public class ExternalDataCache
{
public Dictionary<string, ExternalPickupData> Pickups = new Dictionary<string, ExternalPickupData>();
public Dictionary<string, ExternalSynergyData> Synergies = new Dictionary<string, ExternalSynergyData>();
}
public class ExternalDataSet
{
public ExternalMetadata Metadata;
public Dictionary<string, ExternalPickupData> Items;
public Dictionary<string, ExternalSynergyData> Synergies;
}
public class ExternalPickupData
{
public string Name;
public string Notes;
[JsonIgnore]
public ExternalMetadata SourceMetadata;
}
public class ExternalSynergyData
{
public string Name;
public string Notes;
[JsonIgnore]
public ExternalMetadata SourceMetadata;
}
public class ExternalMetadata
{
public string Name;
public string Version;
public string Url;
}
internal static class HookHelper
{
public static Hook CreateHook(Type sourceType, string sourceMethodName, object newReceiver, string hookMethodName)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
MethodInfo? method = sourceType.GetMethod(sourceMethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
Delegate @delegate = ReflectionHelper.CreateInstanceDelegate(newReceiver, hookMethodName);
return new Hook((MethodBase)method, @delegate);
}
}
public class InternalDataSet
{
public ItemData[] Items = ArrayHelper<ItemData>.Empty;
public SynergyData[] Synergies = ArrayHelper<SynergyData>.Empty;
}
public class SynergyData
{
public string Key;
public PartsList OtherParts;
public string Name;
public string Effect;
public SourceMetadata SourceMetadata;
public bool InternalWouldGetSynergy()
{
if (OtherParts?.Parts == null)
{
return false;
}
bool result = false;
PlayerController[] allPlayers = GameManager.Instance.AllPlayers;
foreach (PlayerController val in allPlayers)
{
int num = 0;
int[] parts = OtherParts.Parts;
for (int j = 0; j < parts.Length; j++)
{
PickupObject byId = PickupObjectDatabase.GetById(parts[j]);
if (byId != null && val.HasPickupID(byId.PickupObjectId))
{
num++;
}
if (OtherParts.PartOperand == PartOperand.One && num > 0)
{
break;
}
}
if (OtherParts.PartOperand == PartOperand.One || OtherParts.PartOperand == PartOperand.OneOrMore)
{
if (num > 0)
{
result = true;
}
}
else if (OtherParts.PartOperand == PartOperand.All && num == OtherParts.Parts.Length)
{
result = true;
}
}
return result;
}
}
public class PartsList
{
private PartOperand? _operand;
public string Operand;
public int[] Parts;
public PartOperand PartOperand
{
get
{
if (!_operand.HasValue)
{
if (string.IsNullOrEmpty(Operand))
{
_operand = PartOperand.Unknown;
}
else if (string.Equals(Operand, "one+", StringComparison.OrdinalIgnoreCase))
{
_operand = PartOperand.OneOrMore;
}
else
{
try
{
_operand = (PartOperand)Enum.Parse(typeof(PartOperand), Operand, ignoreCase: true);
}
catch (Exception)
{
_operand = PartOperand.Unknown;
}
}
}
return _operand.GetValueOrDefault();
}
}
}
public enum PartOperand
{
Unknown,
One,
OneOrMore,
All
}
public class ItemData
{
public string Name;
public int? Id;
public int[] Ids;
public string Notes;
public SynergyData[] Synergies = ArrayHelper<SynergyData>.Empty;
public SourceMetadata SourceMetadata;
}
public class SourceMetadata
{
public string Name;
public string Url;
public string Version;
public static readonly SourceMetadata InternalSource = new SourceMetadata
{
Name = "internal"
};
public override string ToString()
{
return "SourceMetadata:" + Name;
}
}
internal static class ItemTipsConfig
{
public static class ConfigKeys
{
public static readonly string HorizontalPosition = "HorizontalPosition";
public static readonly string VerticalPosition = "VerticalPosition";
public static readonly string TipsEnabled = "TipsEnabled";
public static readonly string AmmonomiconEnabled = "AmmonomiconEnabled";
}
internal static Gunfig _Gunfig = null;
public static readonly float DefaultHorizontalPosition = 0.01f;
public static readonly float DefaultVerticalPosition = 0.2f;
public static readonly string DefaultItem = "Default";
public static bool TipsEnabled = true;
public static bool AmmonomiconEnabled = true;
public static float HorizontalPosition = DefaultHorizontalPosition;
public static float VerticalPosition = DefaultVerticalPosition;
internal static void Init()
{
_Gunfig = Gunfig.Get("ItemTips");
CreateItemTipsMenu(_Gunfig);
TipsEnabled = _Gunfig.Enabled(ConfigKeys.TipsEnabled);
AmmonomiconEnabled = _Gunfig.Enabled(ConfigKeys.AmmonomiconEnabled);
HorizontalPosition = TryGetFloatOrDefault(_Gunfig, ConfigKeys.HorizontalPosition, DefaultHorizontalPosition);
VerticalPosition = TryGetFloatOrDefault(_Gunfig, ConfigKeys.VerticalPosition, DefaultVerticalPosition);
StaticLogger.LogDebug($"{ConfigKeys.TipsEnabled}={TipsEnabled}");
StaticLogger.LogDebug($"{ConfigKeys.AmmonomiconEnabled}={AmmonomiconEnabled}");
StaticLogger.LogDebug($"{ConfigKeys.HorizontalPosition}={HorizontalPosition}");
StaticLogger.LogDebug($"{ConfigKeys.VerticalPosition}={VerticalPosition}");
}
private static void CreateItemTipsMenu(Gunfig gunfig)
{
gunfig.AddToggle(ConfigKeys.TipsEnabled, true, "Tips", (Action<string, string>)delegate(string key, string value)
{
TipsEnabled = value == "1";
StaticLogger.LogDebug($"Config Update {ConfigKeys.TipsEnabled}={TipsEnabled}");
}, (Update)1);
gunfig.AddToggle(ConfigKeys.AmmonomiconEnabled, true, "Extended Ammonomicon", (Action<string, string>)delegate(string key, string value)
{
AmmonomiconEnabled = value == "1";
StaticLogger.LogDebug($"Config Update {ConfigKeys.AmmonomiconEnabled}={AmmonomiconEnabled}");
}, (Update)1);
List<string> list = new List<string> { DefaultItem };
list.AddRange(from i in Enumerable.Range(0, 101)
select ((float)i / 100f).ToString("0.00"));
gunfig.AddScrollBox(ConfigKeys.HorizontalPosition, list, "Horizontal Position", (Action<string, string>)UpdateFloatCallback, (List<string>)null, (Update)1);
gunfig.AddScrollBox(ConfigKeys.VerticalPosition, list, "Vertical Position", (Action<string, string>)UpdateFloatCallback, (List<string>)null, (Update)1);
}
private static void UpdateFloatCallback(string key, string newValue)
{
if (key == ConfigKeys.HorizontalPosition)
{
float result;
if (newValue == DefaultItem)
{
HorizontalPosition = DefaultHorizontalPosition;
}
else if (float.TryParse(newValue, out result))
{
HorizontalPosition = result;
}
StaticLogger.LogDebug($"Config Update {ConfigKeys.HorizontalPosition}={HorizontalPosition}");
}
else if (key == ConfigKeys.VerticalPosition)
{
if (newValue == DefaultItem)
{
VerticalPosition = DefaultVerticalPosition;
}
if (float.TryParse(newValue, out var result2))
{
VerticalPosition = result2;
}
StaticLogger.LogDebug($"Config Update {ConfigKeys.VerticalPosition}={VerticalPosition}");
}
}
private static float TryGetFloatOrDefault(Gunfig gunfig, string key, float defaultValue)
{
string text = gunfig.Value(key);
if (text == null)
{
return defaultValue;
}
if (text == DefaultItem)
{
return defaultValue;
}
if (float.TryParse(text, out var result))
{
return result;
}
return defaultValue;
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("glorfindel.etg.itemtips", "ItemTips", "2.2.0")]
public class ItemTipsModule : BaseUnityPlugin
{
public const string GUID = "glorfindel.etg.itemtips";
public const string NAME = "ItemTips";
public const string VERSION = "2.2.0";
private const string DefaultSynergyHighlightColor = "32C23A";
private const string DefaultCoolnessHighlightColor = "7ACAD6";
private const string DefaultCurseHighlightColor = "745AC7";
private static readonly Color LabelBackgroundColor = new Color(0f, 0f, 0f, 0.5f);
public ConfigEntry<string> ExternalDataPathConfig;
private bool _lateStartCalled;
private Settings _currentSettings;
private Font _gameFont;
private Label _infoLabel;
private NearItemOfInterestModifier _modifier;
private HashSet<int> _specialItemIds;
private PickupAndSynergyDataCache _tipCache;
private AmmonomiconEntryCache _ammonomiconCache;
private AdvancedSynergyCache _synergyCache;
private TipSource? _lastTipSource;
private PlayerControllerObserver _observer;
public ItemTipsModule()
{
_tipCache = new PickupAndSynergyDataCache();
_currentSettings = new Settings();
_synergyCache = new AdvancedSynergyCache();
_ammonomiconCache = new AmmonomiconEntryCache(_synergyCache, _tipCache);
_specialItemIds = new HashSet<int> { 224, 120, 73, 85, 78, 600, 67 };
}
public PickupAndSynergyDataCache GetDataCache()
{
return _tipCache;
}
public AdvancedSynergyCache GetSynergyCache()
{
return _synergyCache;
}
public void CheckForSynergyManagerChanges()
{
if (_synergyCache.SourceEntries != GameManager.Instance.SynergyManager.synergies)
{
StaticLogger.LogDebug("Detected changed source synergies. Reloading...");
_synergyCache = new AdvancedSynergyCache(GameManager.Instance.SynergyManager.synergies);
_ammonomiconCache = new AmmonomiconEntryCache(_synergyCache, _tipCache);
}
}
public void Awake()
{
ExternalDataPathConfig = ((BaseUnityPlugin)this).Config.Bind<string>("Data", "External Data Path", "", "Optional path to directory with external data files. Separate multiple directories with ';'.");
}
public void Start()
{
ETGModMainBehaviour.WaitForGameManagerStart((Action<GameManager>)GmStart);
}
public void GmStart(GameManager gm)
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
try
{
StaticLogger.Source = ((BaseUnityPlugin)this).Logger;
StaticLogger.LogDebug("Loading Config");
ItemTipsConfig.Init();
StaticLogger.LogDebug("Initializing UI");
_infoLabel = new Label();
_modifier = new NearItemOfInterestModifier();
SGUIRoot.Main.Children.Add((SElement)(object)_infoLabel);
((SElement)_infoLabel).Background = LabelBackgroundColor;
((SElement)_infoLabel).OnUpdateStyle = delegate(SElement elem)
{
elem.Font = LoadFont();
((Label)(object)elem).Reposition(ItemTipsConfig.HorizontalPosition, ItemTipsConfig.VerticalPosition);
};
((SElement)_infoLabel).With.Add((SModifier)(object)_modifier);
StaticLogger.LogDebug("Loading internal data");
Stopwatch stopwatch = Stopwatch.StartNew();
_tipCache = Loader.LoadItemData();
_synergyCache = new AdvancedSynergyCache(GameManager.Instance.SynergyManager.synergies);
_ammonomiconCache = new AmmonomiconEntryCache(_synergyCache, _tipCache);
stopwatch.Stop();
StaticLogger.LogDebug($"Loaded {_tipCache.Pickups.Count} items in {stopwatch.ElapsedMilliseconds} ms");
SetupHoooks();
_observer = ((Component)ETGModMainBehaviour.Instance).gameObject.AddComponent<PlayerControllerObserver>();
PlayerControllerObserver observer = _observer;
observer.EnteredCombat = (Action)Delegate.Combine(observer.EnteredCombat, new Action(OnEnteredCombat));
((Component)ETGModMainBehaviour.Instance).gameObject.AddComponent<SynergyManagerMonitorBehaviour>().ItemTips = this;
((Component)ETGModMainBehaviour.Instance).gameObject.AddComponent<CooldownLabelBehavior>();
StaticLogger.LogDebug("Defining commands");
ETGModConsole.Commands.AddGroup("itemtips", (Action<string[]>)delegate
{
HelpCommand(ArrayHelper<string>.Empty);
});
ConsoleCommandGroup group = ETGModConsole.Commands.GetGroup("itemtips");
group.AddUnit("help", (Action<string[]>)HelpCommand);
group.AddUnit("reload", (Action<string[]>)ReloadCommand);
group.AddUnit("generate", (Action<string[]>)GenerateSampleCommand);
DebugHelper.AddDebugCommands(this);
ETGModConsole.Log((object)"ItemTips v2.2.0 loaded", false);
}
catch (Exception arg)
{
StaticLogger.LogError(string.Format("ItemTips v{0} Error: {1}", "2.2.0", arg));
ETGModConsole.Log((object)string.Format("ItemTips v{0} Error: {1}", "2.2.0", arg), false);
}
}
private void SetupHoooks()
{
StaticLogger.LogDebug("Generating hooks");
HookHelper.CreateHook(typeof(Gun), "OnEnteredRange", this, "GunOnEnteredRangeHook");
HookHelper.CreateHook(typeof(Gun), "OnExitRange", this, "GunOnExitRangeHook");
HookHelper.CreateHook(typeof(Gun), "Pickup", this, "GunPickupHook");
HookHelper.CreateHook(typeof(PassiveItem), "OnEnteredRange", this, "PassiveItemOnEnteredRangeHook");
HookHelper.CreateHook(typeof(PassiveItem), "OnExitRange", this, "PassiveItemOnExitRangeHook");
HookHelper.CreateHook(typeof(PassiveItem), "Pickup", this, "PassiveItemPickupHook");
HookHelper.CreateHook(typeof(GungeonMapItem), "Pickup", this, "PassiveItemPickupHook");
HookHelper.CreateHook(typeof(PlayerItem), "OnEnteredRange", this, "ActiveItemOnEnteredRangeHook");
HookHelper.CreateHook(typeof(PlayerItem), "OnExitRange", this, "ActiveItemOnExitRangeHook");
HookHelper.CreateHook(typeof(PlayerItem), "Pickup", this, "ActiveItemPickupHook");
HookHelper.CreateHook(typeof(ShopItemController), "OnEnteredRange", this, "ShopItemOnEnteredRangeHook");
HookHelper.CreateHook(typeof(ShopItemController), "OnExitRange", this, "ShopItemOnExitRangeHook");
HookHelper.CreateHook(typeof(ShopItemController), "Interact", this, "ShopItemInteractHook");
HookHelper.CreateHook(typeof(RewardPedestal), "OnEnteredRange", this, "RewardPedestalOnEnteredRangeHook");
HookHelper.CreateHook(typeof(RewardPedestal), "OnExitRange", this, "RewardPedestalOnExitRangeHook");
HookHelper.CreateHook(typeof(RewardPedestal), "Interact", this, "RewardPedestalInteractHook");
HookHelper.CreateHook(typeof(Chest), "PredictContents", this, "ChestPredictContentsHook");
HookHelper.CreateHook(typeof(HologramDoer), "HideSprite", this, "HologramDoerHideSpriteHook");
HookHelper.CreateHook(typeof(PlayerController), "OnGunChanged", this, "OnGunChangedHook");
HookHelper.CreateHook(typeof(Foyer), "Awake", this, "LateStartAwakeHook");
HookHelper.CreateHook(typeof(EncounterDatabaseEntry), "GetModifiedLongDescription", this, "GetModifiedLongDescriptionHook");
}
private void LateStartAwakeHook(Action<Foyer> orig, Foyer self)
{
orig(self);
if (!_lateStartCalled)
{
_lateStartCalled = true;
try
{
ScanExternalData();
CheckForSynergyManagerChanges();
}
catch (Exception arg)
{
StaticLogger.LogError($"Error automatically loading external files: {arg}");
}
}
}
private int ScanExternalData()
{
int num = 0;
Stopwatch stopwatch = Stopwatch.StartNew();
int num2 = _tipCache.LoadExternalDirectory(Paths.PluginPath);
StaticLogger.LogDebug($"Finished loading external data in BepInEx path . Loaded {num2} items. Elapsed: {stopwatch.ElapsedMilliseconds} ms");
num += num2;
string value = ExternalDataPathConfig.Value;
if (!string.IsNullOrEmpty(value))
{
string[] array = value.Split(new char[1] { ';' });
foreach (string text in array)
{
StaticLogger.LogInfo("Loading external directory: " + text);
Stopwatch stopwatch2 = Stopwatch.StartNew();
int num3 = _tipCache.LoadExternalDirectory(text);
StaticLogger.LogDebug($"Finished loading external data in '{text}'. Loaded {num3} items. Elapsed: {stopwatch2.ElapsedMilliseconds} ms");
num += num3;
}
}
return num;
}
private void HologramDoerHideSpriteHook(Action<HologramDoer, GameObject, bool> orig, HologramDoer self, GameObject gameObject, bool instant)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, gameObject, instant);
}
private void OnEnteredCombat()
{
HideTip();
}
private string GetModifiedLongDescriptionHook(Func<EncounterDatabaseEntry, string> orig, EncounterDatabaseEntry self)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
string text = orig(self);
if (ItemTipsConfig.AmmonomiconEnabled)
{
try
{
_ammonomiconCache.SetCacheLanguage(GameManager.Options.CurrentLanguage);
int pickupObjectId = self.pickupObjectId;
return _ammonomiconCache.GetEntry(pickupObjectId, text);
}
catch (Exception arg)
{
StaticLogger.LogError(string.Format("Error in {0}: {1}", "GetModifiedLongDescriptionHook", arg));
}
}
return text;
}
private void HelpCommand(string[] args)
{
if (args.Length != 0)
{
string text = args[0].ToLowerInvariant();
switch (text)
{
case "reload":
ETGModConsole.Log((object)"Reloads external item description files", false);
break;
case "generate":
ETGModConsole.Log((object)"Generates a sample external item description file", false);
break;
case "help":
ETGModConsole.Log((object)"Help generates help", false);
break;
default:
ETGModConsole.Log((object)("Unknown command " + text), false);
break;
}
}
else
{
ETGModConsole.Log((object)"ItemTips v2.2.0 command help", false);
ETGModConsole.Log((object)"itemtips reload - Reload external tip files", false);
ETGModConsole.Log((object)"itemtips generate - Create sample external tip file", false);
ETGModConsole.Log((object)"itemtips help [command] - Additional help about the command", false);
}
}
private void GenerateSampleCommand(string[] args)
{
char[] separator = new char[1] { ':' };
string text = null;
try
{
HashSet<string> hashSet = new HashSet<string>(args ?? ArrayHelper<string>.Empty);
ExternalDataSet externalDataSet = new ExternalDataSet
{
Metadata = new ExternalMetadata
{
Name = "",
Url = "",
Version = ""
},
Items = new Dictionary<string, ExternalPickupData>(),
Synergies = new Dictionary<string, ExternalSynergyData>()
};
foreach (KeyValuePair<string, PickupObject> pair in Game.Items.Pairs)
{
if (string.IsNullOrEmpty(pair.Key) || _specialItemIds.Contains(pair.Value.PickupObjectId))
{
continue;
}
string text2 = pair.Key;
bool flag = false;
string item;
if (text2.StartsWith("gungeon:"))
{
item = "gungeon";
if (text2.Contains("_dupe") || (text2.Contains("+") && text2 != "gungeon:+1_bullets"))
{
continue;
}
text2 = text2.Substring("gungeon:".Length);
flag = true;
}
else
{
item = text2.Split(separator)[0];
}
string text3 = null;
if (_tipCache.Pickups.TryGetValue(pair.Value.PickupObjectId, out var value))
{
text3 = value.Notes;
}
else if (flag)
{
continue;
}
if (hashSet.Count <= 0 || hashSet.Contains(item))
{
externalDataSet.Items[text2] = new ExternalPickupData
{
Name = pair.Value.EncounterNameOrDisplayName,
Notes = (text3 ?? string.Empty)
};
}
}
foreach (KeyValuePair<string, SynergyGroup> item2 in _synergyCache.SynergyKeyIndex)
{
string text4 = null;
if (_tipCache.Synergies.TryGetValue(item2.Value.NameKey, out var value2))
{
text4 = value2.Effect;
string synergyString = StringTableManager.GetSynergyString(item2.Key, -1);
externalDataSet.Synergies[item2.Key] = new ExternalSynergyData
{
Name = synergyString,
Notes = (text4 ?? string.Empty)
};
}
}
string path = Loader.DataFilePrefix + "-sample" + Loader.DataFileExtension;
text = Path.Combine(Environment.GetEnvironmentVariable("HOME") ?? Environment.GetFolderPath(Environment.SpecialFolder.Personal), path);
JsonHelper.SerializeToFile(text, externalDataSet);
long length = new FileInfo(text).Length;
StaticLogger.LogInfo($"Wrote {length} bytes to to {text}");
ETGModConsole.Log((object)("Wrote sample file to " + text), false);
}
catch (Exception ex)
{
if (text != null)
{
StaticLogger.LogError($"Error creating sample file: '{text}' {ex}");
ETGModConsole.Log((object)$"Error creating sample file: '{text}' {ex}", false);
}
else
{
StaticLogger.LogError($"Error creating sample file: {ex}");
ETGModConsole.Log((object)$"Error creating sample file: {ex}", false);
}
}
}
private void ReloadCommand(string[] args)
{
int num = ScanExternalData();
ETGModConsole.Log((object)$"ItemTips reloaded {num} items", false);
}
private Font LoadFont()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
if ((Object)(object)_gameFont == (Object)null)
{
dfFont val = (dfFont)GameUIRoot.Instance.Manager.DefaultFont;
_gameFont = FontConverter.GetFontFromdfFont(val, 2);
}
return _gameFont;
}
private void GunOnEnteredRangeHook(Action<Gun, PlayerController> orig, Gun self, PlayerController player)
{
try
{
if (ItemTipsConfig.TipsEnabled)
{
ShowTip(TipSource.Gun, ((PickupObject)self).PickupObjectId);
}
}
catch (Exception arg)
{
StaticLogger.LogDebug(string.Format("Error in {0}: {1}", "GunOnEnteredRangeHook", arg));
}
orig(self, player);
}
private void GunOnExitRangeHook(Action<Gun, PlayerController> orig, Gun self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void GunPickupHook(Action<Gun, PlayerController> orig, Gun self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void PassiveItemOnEnteredRangeHook(Action<PassiveItem, PlayerController> orig, PassiveItem self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
ShowTip(TipSource.PassiveItem, ((PickupObject)self).PickupObjectId);
}
orig(self, player);
}
private void PassiveItemOnExitRangeHook(Action<PassiveItem, PlayerController> orig, PassiveItem self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void PassiveItemPickupHook(Action<PassiveItem, PlayerController> orig, PassiveItem self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void ActiveItemOnEnteredRangeHook(Action<PlayerItem, PlayerController> orig, PlayerItem self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
ShowTip(TipSource.ActiveItem, ((PickupObject)self).PickupObjectId);
}
orig(self, player);
}
private void ActiveItemOnExitRangeHook(Action<PlayerItem, PlayerController> orig, PlayerItem self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void ActiveItemPickupHook(Action<PlayerItem, PlayerController> orig, PlayerItem self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void ShopItemOnEnteredRangeHook(Action<ShopItemController, PlayerController> orig, ShopItemController self, PlayerController player)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Invalid comparison between Unknown and I4
if (ItemTipsConfig.TipsEnabled && Object.op_Implicit((Object)(object)self.item))
{
int pickupId = (((int)self.CurrencyType != 1) ? self.item.PickupObjectId : (PickupObjectDatabase.GetByEncounterName(self.item.EncounterNameOrDisplayName)?.PickupObjectId ?? (-1)));
ShowTip(TipSource.ShopItem, pickupId);
}
orig(self, player);
}
private void ShopItemOnExitRangeHook(Action<ShopItemController, PlayerController> orig, ShopItemController self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void ShopItemInteractHook(Action<ShopItemController, PlayerController> orig, ShopItemController self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void RewardPedestalOnEnteredRangeHook(Action<RewardPedestal, PlayerController> orig, RewardPedestal self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
int pickupId = self.contents?.PickupObjectId ?? (-1);
ShowTip(TipSource.RewardPedestal, pickupId);
}
orig(self, player);
}
private void RewardPedestalOnExitRangeHook(Action<RewardPedestal, PlayerController> orig, RewardPedestal self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private void RewardPedestalInteractHook(Action<RewardPedestal, PlayerController> orig, RewardPedestal self, PlayerController player)
{
if (ItemTipsConfig.TipsEnabled)
{
HideTip();
}
orig(self, player);
}
private List<PickupObject> ChestPredictContentsHook(Func<Chest, PlayerController, List<PickupObject>> orig, Chest self, PlayerController player)
{
List<PickupObject> list = orig(self, player);
if (list.Count > 0 && ItemTipsConfig.TipsEnabled)
{
ShowTip(TipSource.ChestPredicted, list[0].PickupObjectId);
}
return list;
}
private void OnGunChangedHook(Action<PlayerController, Gun, Gun, Gun, Gun, bool> orig, PlayerController self, Gun previous, Gun current, Gun previousSecondary, Gun currentSecondary, bool newGun)
{
if (ItemTipsConfig.TipsEnabled && _lastTipSource.GetValueOrDefault() == TipSource.ChestPredicted)
{
HideTip();
}
orig(self, previous, current, previousSecondary, currentSecondary, newGun);
}
private void ShrineOnEnteredRangeHook(Action<AdvancedShrineController, PlayerController> orig, AdvancedShrineController self, PlayerController player)
{
orig(self, player);
}
private void ShrineOnExitRangeHook(Action<AdvancedShrineController, PlayerController> orig, AdvancedShrineController self, PlayerController player)
{
orig(self, player);
}
private void ShowTip(TipSource source, int pickupId)
{
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
if (pickupId < 0)
{
_modifier.IsNearItem = false;
_lastTipSource = null;
return;
}
try
{
if (_specialItemIds.Contains(pickupId))
{
_modifier.IsNearItem = false;
_lastTipSource = null;
return;
}
PickupObject byId = PickupObjectDatabase.GetById(pickupId);
if (!_tipCache.Pickups.TryGetValue(pickupId, out var value))
{
value = null;
}
TextInfo textInfo = GenerateTextInfo(byId, value);
((SLabel)_infoLabel).Text = textInfo.LabelText;
((SElement)_infoLabel).Size = textInfo.LabelSize;
_modifier.IsNearItem = true;
_lastTipSource = source;
_infoLabel.Reposition(ItemTipsConfig.HorizontalPosition, ItemTipsConfig.VerticalPosition);
}
catch (Exception arg)
{
StaticLogger.LogDebug($"ShowTip Error {source} '{pickupId}': {arg}");
}
}
private void HideTip()
{
_modifier.IsNearItem = false;
_lastTipSource = null;
}
private TextInfo GenerateTextInfo(PickupObject pickup, ItemData item)
{
//IL_036d: Unknown result type (might be due to invalid IL or missing references)
//IL_0372: Unknown result type (might be due to invalid IL or missing references)
//IL_0389: Unknown result type (might be due to invalid IL or missing references)
List<string> lines = new List<string> { pickup.EncounterNameOrDisplayName };
TipBuilder.AppendQualityDescriptor(pickup, delegate(string line)
{
lines.Add(line);
});
EncounterDatabaseEntry entry = EncounterDatabase.GetEntry(((BraveBehaviour)pickup).encounterTrackable.EncounterGuid);
if (entry != null)
{
string secondTapeDescriptor = entry.GetSecondTapeDescriptor();
if (entry.shootStyleInt >= 0)
{
lines.Add("Style: " + secondTapeDescriptor);
}
else if (entry.isPassiveItem || entry.isPlayerItem)
{
lines.Add("Type: " + secondTapeDescriptor);
}
}
TipBuilder.AppendActiveCooldownType(pickup, delegate(string line)
{
lines.Add(line);
});
if (item != null && !string.IsNullOrEmpty(item.Notes))
{
List<string> collection = ConvertStringToFixedWidthLines(item.Notes, _currentSettings.LineWidth);
lines.AddRange(collection);
}
TipBuilder.AppendModifiers(pickup, delegate(StatType stat, string line)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Invalid comparison between Unknown and I4
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Invalid comparison between Unknown and I4
string text3 = null;
if ((int)stat != 4)
{
if ((int)stat == 14)
{
text3 = "745AC7";
}
}
else
{
text3 = "7ACAD6";
}
if (string.IsNullOrEmpty(text3))
{
lines.Add(line);
}
else
{
lines.Add("<color=#" + text3 + ">" + line + "</color>");
}
});
HashSet<string> hashSet = new HashSet<string>();
if (_synergyCache.ItemIndex.TryGetValue(pickup.PickupObjectId, out var value) && value.Count > 0)
{
lines.Add("Synergies:");
foreach (SynergyGroup item2 in value)
{
string synergyString = StringTableManager.GetSynergyString(item2.NameKey, -1);
if (!hashSet.Add(synergyString))
{
continue;
}
string text = null;
bool num = item2.SynergyIsAvailable(GameManager.Instance.PrimaryPlayer, GameManager.Instance.SecondaryPlayer, pickup.PickupObjectId);
if (num && _tipCache.Synergies.TryGetValue(item2.NameKey, out var value2))
{
text = value2.Effect;
}
if (num)
{
if (!string.IsNullOrEmpty(text))
{
lines.Add(" - <color=#32C23A>" + synergyString + "</color>:");
List<string> collection2 = ConvertStringToFixedWidthLines(text, _currentSettings.LineWidth);
lines.AddRange(collection2);
}
else
{
lines.Add(" - <color=#32C23A>" + synergyString + "</color>");
}
}
else
{
lines.Add(" - " + synergyString);
}
}
}
if (item != null && item.Synergies.Length != 0)
{
if (hashSet.Count == 0)
{
lines.Add("Synergies:");
}
SynergyData[] synergies = item.Synergies;
foreach (SynergyData synergyData in synergies)
{
string localizedSynergyName = synergyData.GetLocalizedSynergyName();
if (!hashSet.Add(localizedSynergyName) || (synergyData.Key != null && hashSet.Contains(synergyData.Key)))
{
continue;
}
string text2 = null;
bool num2 = synergyData.InternalWouldGetSynergy();
if (num2)
{
text2 = synergyData.Effect;
}
if (num2)
{
if (!string.IsNullOrEmpty(text2))
{
lines.Add(" - <color=#32C23A>" + localizedSynergyName + "</color>:");
List<string> collection3 = ConvertStringToFixedWidthLines(text2, _currentSettings.LineWidth);
lines.AddRange(collection3);
}
else
{
lines.Add(" - <color=#32C23A>" + localizedSynergyName + "</color>");
}
}
else
{
lines.Add(" - " + localizedSynergyName);
}
}
}
Vector2 size = _currentSettings.GetSize(lines.Count);
return new TextInfo(string.Join("\n", lines.ToArray()), size);
}
private static List<string> ConvertStringToFixedWidthLines(string text, int lineWidth)
{
List<string> list = new List<string>();
if (text.Length < lineWidth)
{
list.Add(text);
}
else
{
string[] array = text.Split();
StringBuilder stringBuilder = new StringBuilder();
string[] array2 = array;
foreach (string text2 in array2)
{
if (stringBuilder.Length + text2.Length + 1 >= lineWidth)
{
list.Add(stringBuilder.ToString());
stringBuilder.Length = 0;
stringBuilder.Append(text2);
continue;
}
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" ");
}
stringBuilder.Append(text2);
}
if (stringBuilder.Length > 0)
{
list.Add(stringBuilder.ToString());
}
}
return list;
}
}
public enum ItemType
{
None,
Gun,
Passive,
Active,
Synergy
}
internal static class JsonHelper
{
private static readonly JsonSerializerSettings DefaultSettings = new JsonSerializerSettings
{
Formatting = (Formatting)1,
ContractResolver = (IContractResolver)new CamelCasePropertyNamesContractResolver()
};
private static readonly JsonSerializer Serializer = JsonSerializer.Create(DefaultSettings);
public static T DeserializeFromFile<T>(string filePath)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
using StreamReader streamReader = new StreamReader(filePath);
JsonTextReader val = new JsonTextReader((TextReader)streamReader);
try
{
return Serializer.Deserialize<T>((JsonReader)(object)val);
}
finally
{
((IDisposable)val)?.Dispose();
}
}
public static T DeserializeFromStream<T>(Stream inputStream)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
using StreamReader streamReader = new StreamReader(inputStream);
JsonTextReader val = new JsonTextReader((TextReader)streamReader);
try
{
return Serializer.Deserialize<T>((JsonReader)(object)val);
}
finally
{
((IDisposable)val)?.Dispose();
}
}
public static void SerializeToFile(string filePath, object obj)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
using StreamWriter streamWriter = new StreamWriter(filePath, append: false);
JsonTextWriter val = new JsonTextWriter((TextWriter)streamWriter);
try
{
Serializer.Serialize((JsonWriter)(object)val, obj);
}
finally
{
((IDisposable)val)?.Dispose();
}
}
}
internal class Label : SLabel
{
public void Reposition(float leftFraction, float topFraction)
{
//IL_0014: 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)
if (((SElement)this).Root != null)
{
((SElement)this).Position.x = ((SElement)this).Root.Size.x * leftFraction;
((SElement)this).Position.y = ((SElement)this).Root.Size.y * topFraction;
}
}
}
public static class Loader
{
public static bool ThrowIfException = DefaultThrowSetting();
public static string DataFilePrefix { get; } = "itemtips";
public static string DataFileExtension { get; } = ".tip";
internal static string SearchPattern { get; } = DataFilePrefix + "*" + DataFileExtension;
public static PickupAndSynergyDataCache LoadItemData()
{
PickupAndSynergyDataCache pickupAndSynergyDataCache = new PickupAndSynergyDataCache();
try
{
InternalDataSet internalDataSet = GetInternalDataSet();
ItemData[] items = internalDataSet.Items;
foreach (ItemData itemData in items)
{
itemData.SourceMetadata = SourceMetadata.InternalSource;
if (itemData.Id.HasValue)
{
pickupAndSynergyDataCache.Pickups[itemData.Id.GetValueOrDefault()] = itemData;
}
else if (itemData.Ids != null)
{
int[] ids = itemData.Ids;
foreach (int key in ids)
{
pickupAndSynergyDataCache.Pickups[key] = itemData;
}
}
else
{
StaticLogger.LogDebug("Could not process item '" + itemData.Name + "' because it does not have an id");
}
SynergyData[] synergies = internalDataSet.Synergies;
foreach (SynergyData synergyData in synergies)
{
synergyData.SourceMetadata = SourceMetadata.InternalSource;
if (synergyData.Key != null && synergyData.Key.StartsWith("#"))
{
pickupAndSynergyDataCache.Synergies[synergyData.Key] = synergyData;
}
else
{
StaticLogger.LogDebug("Could not process item '" + synergyData.Name + "' because it does not have a proper id");
}
}
}
}
catch (Exception arg) when (!ThrowIfException)
{
StaticLogger.LogInfo($"Error processing item data: {arg}");
}
return pickupAndSynergyDataCache;
}
public static ExternalDataCache LoadExternalTips(string directory)
{
ExternalDataCache externalDataCache = new ExternalDataCache();
try
{
if (Directory.Exists(directory))
{
int num = 0;
string[] files = Directory.GetFiles(directory, SearchPattern, SearchOption.AllDirectories);
foreach (string text in files)
{
try
{
num++;
ProcessJsonFile(externalDataCache, text);
}
catch (Exception arg)
{
StaticLogger.LogError($"Failed to read external file '{text}': {arg}");
}
}
StaticLogger.LogDebug($"Files processed: {num}");
}
else
{
StaticLogger.LogDebug("Directory does not exist: " + directory);
}
}
catch (Exception arg2)
{
StaticLogger.LogInfo($"Failed to read resource directory '{directory}': {arg2}");
}
return externalDataCache;
}
internal static InternalDataSet GetInternalDataSet()
{
string[] manifestResourceNames = typeof(ItemTipsModule).Assembly.GetManifestResourceNames();
foreach (string text in manifestResourceNames)
{
if (!text.Contains("data.json"))
{
continue;
}
using Stream inputStream = typeof(ItemTipsModule).Assembly.GetManifestResourceStream(text);
InternalDataSet internalDataSet = JsonHelper.DeserializeFromStream<InternalDataSet>(inputStream);
if (internalDataSet != null && internalDataSet.Items != null)
{
return internalDataSet;
}
StaticLogger.LogDebug("Found stream " + text + " but had no data");
}
throw new InvalidOperationException("Could not find internal data set");
}
private static void ProcessJsonFile(ExternalDataCache cache, string file)
{
StaticLogger.LogInfo("Reading file: " + file);
using FileStream jsonStream = File.OpenRead(file);
ProcessJsonFromStream(cache, jsonStream, "file " + file);
}
private static void ProcessJsonFromStream(ExternalDataCache cache, Stream jsonStream, string descriptor)
{
try
{
ExternalDataSet externalDataSet = JsonHelper.DeserializeFromStream<ExternalDataSet>(jsonStream);
if (externalDataSet.Metadata != null)
{
StaticLogger.LogDebug("name:" + externalDataSet.Metadata.Name + ", version:" + externalDataSet.Metadata.Version);
}
Dictionary<string, ExternalPickupData> dictionary = externalDataSet?.Items;
if (dictionary != null && dictionary.Count > 0)
{
foreach (KeyValuePair<string, ExternalPickupData> item in dictionary)
{
ExternalPickupData value = item.Value;
value.SourceMetadata = externalDataSet.Metadata;
if (!string.IsNullOrEmpty(value.Notes) && !value.Notes.EndsWith("."))
{
value.Notes += ".";
}
cache.Pickups[item.Key] = item.Value;
}
}
Dictionary<string, ExternalSynergyData> dictionary2 = externalDataSet?.Synergies;
if (dictionary2 != null && dictionary2.Count > 0)
{
foreach (KeyValuePair<string, ExternalSynergyData> item2 in dictionary2)
{
ExternalSynergyData value2 = item2.Value;
value2.SourceMetadata = externalDataSet.Metadata;
if (!string.IsNullOrEmpty(value2.Notes) && !value2.Notes.EndsWith("."))
{
value2.Notes += ".";
}
cache.Synergies[item2.Key] = item2.Value;
}
}
if (cache.Pickups.Count == 0 && cache.Synergies.Count == 0)
{
StaticLogger.LogDebug("Nothing found to load in " + descriptor);
}
}
catch (Exception arg)
{
StaticLogger.LogError($"Failed to read json from {descriptor}: {arg}");
}
}
private static bool DefaultThrowSetting()
{
return false;
}
}
internal class NearItemOfInterestModifier : SModifier
{
public bool IsNearItem;
public override void Update()
{
base.Elem.Enabled = ItemTipsConfig.TipsEnabled;
if (GameManager.Instance.IsPaused)
{
base.Elem.Visible = false;
}
else
{
base.Elem.Visible = IsNearItem;
}
}
}
public class PickupAndSynergyDataCache
{
public Dictionary<int, ItemData> Pickups = new Dictionary<int, ItemData>();
public Dictionary<string, SynergyData> Synergies = new Dictionary<string, SynergyData>();
public int LoadExternalDirectory(string directory)
{
int num = 0;
try
{
if (string.IsNullOrEmpty(directory))
{
StaticLogger.LogDebug("Skipped loading external files because directory was not set.");
return 0;
}
ExternalDataCache externalDataCache = Loader.LoadExternalTips(directory);
if (externalDataCache.Pickups.Count == 0 && externalDataCache.Synergies.Count == 0)
{
return num;
}
int num2 = 0;
foreach (KeyValuePair<string, ExternalPickupData> pickup in externalDataCache.Pickups)
{
string key = pickup.Key;
ExternalPickupData value = pickup.Value;
if (string.IsNullOrEmpty(value.Notes))
{
StaticLogger.LogDebug("Skipped item: " + key + ", no 'Notes' set.");
num2++;
continue;
}
if (!Game.Items.ContainsID(key))
{
StaticLogger.LogDebug("Skipped item: " + key + ", game has not loaded it.");
num2++;
continue;
}
PickupObject val = Game.Items[key];
if (val.PickupObjectId < 0)
{
StaticLogger.LogDebug("Skipped item: " + key + ", pickup has not been assigned an id.");
num2++;
continue;
}
SourceMetadata sourceMetadata = null;
if (Pickups.TryGetValue(val.PickupObjectId, out var value2))
{
if (value2.SourceMetadata == SourceMetadata.InternalSource)
{
sourceMetadata = SourceMetadata.InternalSource;
}
else if (value.SourceMetadata != null)
{
sourceMetadata = new SourceMetadata
{
Name = value.SourceMetadata.Name,
Version = value.SourceMetadata.Version,
Url = value.SourceMetadata.Url
};
}
}
else
{
sourceMetadata = new SourceMetadata
{
Name = value.SourceMetadata.Name,
Version = value.SourceMetadata.Version,
Url = value.SourceMetadata.Url
};
}
Pickups[val.PickupObjectId] = new ItemData
{
Name = (value.Name ?? key),
Notes = value.Notes,
SourceMetadata = sourceMetadata
};
num++;
}
foreach (KeyValuePair<string, ExternalSynergyData> synergy in externalDataCache.Synergies)
{
string key2 = synergy.Key;
ExternalSynergyData value3 = synergy.Value;
if (string.IsNullOrEmpty(value3.Notes))
{
StaticLogger.LogDebug("Skipped synergy: " + key2 + ", no 'Notes' set.");
num2++;
continue;
}
SourceMetadata sourceMetadata2 = null;
if (Synergies.TryGetValue(key2, out var value4))
{
if (value4.SourceMetadata == SourceMetadata.InternalSource)
{
sourceMetadata2 = SourceMetadata.InternalSource;
}
else if (value3.SourceMetadata != null)
{
sourceMetadata2 = new SourceMetadata
{
Name = value3.SourceMetadata.Name,
Version = value3.SourceMetadata.Version,
Url = value3.SourceMetadata.Url
};
}
}
else
{
sourceMetadata2 = new SourceMetadata
{
Name = value3.SourceMetadata.Name,
Version = value3.SourceMetadata.Version,
Url = value3.SourceMetadata.Url
};
}
Synergies[key2] = new SynergyData
{
Name = (value3.Name ?? key2),
Effect = value3.Notes,
SourceMetadata = sourceMetadata2
};
num++;
}
StaticLogger.LogDebug($"Loaded external tips:{num}, skipped:{num2}");
return num;
}
catch (Exception arg)
{
StaticLogger.LogError($"Failed to load external data. Error: {arg}");
return num;
}
}
}
public class PlayerControllerObserver : MonoBehaviour
{
private Func<PlayerController, IPlayerInteractable> getLastInteractable;
public float TimeBetweenChecks = 1f;
public Action EnteredCombat;
public Action ExitedCombat;
public Action<PlayerController, IPlayerInteractable> LastInteractableChanged;
private float TimeCounter;
private bool _currentlyInCombat;
private IPlayerInteractable _lastInteractable;
private void Start()
{
try
{
getLastInteractable = ReflectionHelper.CreatePrivateFieldGetter<PlayerController, IPlayerInteractable>("m_lastInteractionTarget");
}
catch (Exception arg)
{
StaticLogger.LogInfo($"Cannot inspect player interactions: {arg}");
}
}
private void Update()
{
TimeCounter -= Time.deltaTime;
if (!(TimeCounter <= 0f))
{
return;
}
TimeCounter = TimeBetweenChecks;
try
{
bool flag = false;
PlayerController[] allPlayers = GameManager.Instance.AllPlayers;
foreach (PlayerController val in allPlayers)
{
if (val.IsInCombat)
{
flag = true;
break;
}
IPlayerInteractable val2 = getLastInteractable(val);
if (_lastInteractable != val2)
{
_lastInteractable = val2;
LastInteractableChanged?.Invoke(val, _lastInteractable);
break;
}
}
if (_currentlyInCombat != flag)
{
_currentlyInCombat = flag;
if (flag)
{
EnteredCombat?.Invoke();
}
else
{
ExitedCombat?.Invoke();
}
}
}
catch (Exception arg)
{
StaticLogger.LogDebug($"Error in Update: {arg}");
}
}
}
internal delegate void Action<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
internal delegate void Action<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
internal delegate void Action<T1, T2, T3, T4, T5, T6, T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
internal static class ReflectionHelper
{
private static Type[] ActionDelegateTypes = new Type[8]
{
typeof(Action),
typeof(Action<>),
typeof(Action<, >),
typeof(Action<, , >),
typeof(Action<, , , >),
typeof(Action<, , , , >),
typeof(Action<, , , , , >),
typeof(Action<, , , , , , >)
};
private static Type[] FuncDelegateTypes = new Type[5]
{
typeof(Func<>),
typeof(Func<, >),
typeof(Func<, , >),
typeof(Func<, , , >),
typeof(Func<, , , , >)
};
public static Func<TTarget, TField> CreatePrivateFieldGetter<TTarget, TField>(string fieldName)
{
FieldInfo field = typeof(TTarget).GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
if ((object)field == null)
{
throw new ArgumentException($"Private instance field {fieldName} was not found on {typeof(TTarget)}");
}
return (TTarget t) => (TField)field.GetValue(t);
}
public static Delegate CreateInstanceDelegate(object source, string name)
{
MethodInfo method = source.GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if ((object)method == null)
{
throw new ArgumentException($"Method '{name}' not found on {source.GetType()}");
}
Type[] array = (((object)method.ReturnType != typeof(void)) ? FuncDelegateTypes : ActionDelegateTypes);
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length >= array.Length)
{
throw new ArgumentException($"Too many parameters for delegate types:{parameters.Length}");
}
Type type = array[parameters.Length];
Type type2;
if (type.IsGenericType)
{
List<Type> list = new List<Type>(parameters.Select((ParameterInfo p) => p.ParameterType));
if ((object)method.ReturnType == typeof(void))
{
type2 = type.MakeGenericType(list.ToArray());
}
else
{
list.Add(method.ReturnType);
type2 = type.MakeGenericType(list.ToArray());
}
}
else
{
type2 = type;
}
return Delegate.CreateDelegate(type2, source, method);
}
}
public class Settings
{
public int LineWidth = 40;
public Vector2 GetSize(int linesHeight)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
return new Vector2(11f * (float)LineWidth, 32f * (float)linesHeight);
}
}
internal static class StaticLogger
{
public static ManualLogSource Source;
public static void LogInfo(string message)
{
ManualLogSource source = Source;
if (source != null)
{
source.LogInfo((object)message);
}
}
public static void LogDebug(string message)
{
ManualLogSource source = Source;
if (source != null)
{
source.LogDebug((object)message);
}
}
public static void LogDebug<T>(string format, T arg)
{
ManualLogSource source = Source;
if (source != null)
{
source.LogDebug((object)string.Format(format, arg));
}
}
public static void LogDebug(string format, params object[] args)
{
ManualLogSource source = Source;
if (source != null)
{
source.LogDebug((object)string.Format(format, args));
}
}
public static void LogError(string format, params object[] args)
{
ManualLogSource source = Source;
if (source != null)
{
source.LogError((object)string.Format(format, args));
}
}
}
internal static class SynergyDataExtensions
{
public static string GetLocalizedSynergyName(this SynergyData synergy)
{
if (synergy.Key == null)
{
return synergy.Name;
}
string synergyString = StringTableManager.GetSynergyString(synergy.Key, -1);
if (string.IsNullOrEmpty(synergyString))
{
StaticLogger.LogDebug("Did not get localized name for " + synergy.Key);
return synergy.Key;
}
return synergyString;
}
}
internal class SynergyManagerMonitorBehaviour : MonoBehaviour
{
public ItemTipsModule ItemTips;
private void Update()
{
if ((Object)(object)ItemTips != (Object)null)
{
ItemTips.CheckForSynergyManagerChanges();
}
}
}
internal struct TextInfo
{
public readonly string LabelText;
public readonly Vector2 LabelSize;
public TextInfo(string text, Vector2 size)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
LabelText = text;
LabelSize = size;
}
}
internal static class TipBuilder
{
public static void AppendQualityDescriptor(PickupObject pickup, Action<string> appendLine)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Invalid comparison between Unknown and I4
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
if ((int)pickup.quality != 0 && (int)pickup.quality != -100 && (int)pickup.quality != -50)
{
if (pickup.ItemSpansBaseQualityTiers || pickup.ItemRespectsHeartMagnificence)
{
appendLine("Quality: C/B/A");
}
else
{
appendLine($"Quality: {pickup.quality}");
}
}
}
public static void AppendActiveCooldownType(PickupObject pickup, Action<string> appendLine)
{
PlayerItem val = (PlayerItem)(object)((pickup is PlayerItem) ? pickup : null);
if (val != null)
{
if (val.roomCooldown > 0)
{
appendLine("Cooldown: Room");
}
else if (val.damageCooldown > 0f)
{
appendLine("Cooldown: Damage");
}
else if (val.timeCooldown > 0f)
{
appendLine("Cooldown: Time");
}
}
}
public static void AppendModifiers(PickupObject pickup, Action<StatType, string> appendLine)
{
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Invalid comparison between Unknown and I4
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Invalid comparison between Unknown and I4
List<StatModifier> list = new List<StatModifier>();
Gun val = (Gun)(object)((pickup is Gun) ? pickup : null);
if (val == null)
{
BasicStatPickup val2 = (BasicStatPickup)(object)((pickup is BasicStatPickup) ? pickup : null);
if (val2 == null)
{
PassiveItem val3 = (PassiveItem)(object)((pickup is PassiveItem) ? pickup : null);
if (val3 == null)
{
PlayerItem val4 = (PlayerItem)(object)((pickup is PlayerItem) ? pickup : null);
if (val4 == null)
{
StaticLogger.LogDebug("Could not get stat modifiers: " + pickup.EncounterNameOrDisplayName);
return;
}
if (val4.passiveStatModifiers != null)
{
list.AddRange(val4.passiveStatModifiers);
}
}
else if (val3.passiveStatModifiers != null)
{
list.AddRange(val3.passiveStatModifiers);
}
}
else
{
if (((PassiveItem)val2).passiveStatModifiers != null)
{
list.AddRange(((PassiveItem)val2).passiveStatModifiers);
}
if (val2.modifiers != null)
{
list.AddRange(val2.modifiers);
}
}
}
else if (val.passiveStatModifiers != null)
{
list.AddRange(val.passiveStatModifiers);
}
if (list.Count <= 0)
{
return;
}
float num = 0f;
float num2 = 0f;
foreach (StatModifier item in list)
{
if ((int)item.statToBoost == 14)
{
num += item.amount;
}
else if ((int)item.statToBoost == 4)
{
num2 += item.amount;
}
}
if (num > 0f)
{
appendLine((StatType)14, $"Curse: +{num}");
}
if (num2 > 0f)
{
appendLine((StatType)4, $"Coolness: +{num2}");
}
}
}
public enum TipSource
{
Gun,
ActiveItem,
PassiveItem,
ShopItem,
RewardPedestal,
ChestPredicted
}
