using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ComfyLib;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PassWard")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PassWard")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f51143e3-8886-4bc6-901c-89f307cc9714")]
[assembly: AssemblyFileVersion("1.3.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace PassWard
{
public static class PluginConfig
{
public enum UserListSeperator
{
Newline,
Comma
}
public enum UserListSorting
{
Unsorted,
Alphabetically,
ReverseAlphabetically
}
public static ConfigEntry<bool> IsModEnabled { get; private set; }
public static ConfigEntry<KeyboardShortcut> EnterPasswordKey { get; private set; }
public static ConfigEntry<KeyboardShortcut> RemovePasswordKey { get; private set; }
public static ConfigEntry<UserListSeperator> WardHoverTextUserListSeparator { get; private set; }
public static ConfigEntry<UserListSorting> WardHoverTextUserListSorting { get; private set; }
public static void BindConfig(ConfigFile config)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
IsModEnabled = config.BindInOrder("_Global", "isModEnabled", defaultValue: true, "Globally enable or disable this mod.");
EnterPasswordKey = config.BindInOrder<KeyboardShortcut>("Hotkeys", "enterPasswordShortcut", new KeyboardShortcut((KeyCode)112, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Enter password into a passworded ward OR assign password to own ward.");
RemovePasswordKey = config.BindInOrder<KeyboardShortcut>("Hotkeys", "removePasswordKey", new KeyboardShortcut((KeyCode)114, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Removes password on player's own passworded ward.");
WardHoverTextUserListSeparator = config.BindInOrder("HoverText", "userListSeparator", UserListSeperator.Newline, "Separator to use between player names for a ward's hover-text.");
WardHoverTextUserListSorting = config.BindInOrder("HoverText", "userListSorting", UserListSorting.Unsorted, "What sorting (if any) to use for player names for a ward's hover-text.");
WardHoverTextUserListSorting.OnSettingChanged<UserListSorting>(WardManager.ClearCachedPermittedPlayerNames);
}
}
public sealed class TryPasswordReceiver : TextReceiver
{
private readonly PrivateArea _privateArea;
public TryPasswordReceiver(PrivateArea privateArea)
{
_privateArea = privateArea;
}
public string GetText()
{
return string.Empty;
}
public void SetText(string enteredPassword)
{
int @int = _privateArea.m_nview.GetZDO().GetInt(1595635768, -1);
if (@int == -1)
{
WardManager.ShowMessage("No password on ward.");
}
else if (StringExtensionMethods.GetStableHashCode(enteredPassword) != @int)
{
WardManager.ShowMessage("Incorrect password.");
}
else
{
WardManager.OptPlayerIn(_privateArea);
}
}
}
public sealed class WardPasswordReceiver : TextReceiver
{
private readonly PrivateArea _privateArea;
public WardPasswordReceiver(PrivateArea privateArea)
{
_privateArea = privateArea;
}
public string GetText()
{
return string.Empty;
}
public void SetText(string password)
{
_privateArea.m_nview.GetZDO().Set(1595635768, StringExtensionMethods.GetStableHashCode(password), false);
WardManager.ShowMessage("Password set.");
}
}
public static class WardManager
{
public const int GuardStoneHash = -1024209535;
public const int PasswordHash = 1595635768;
private static readonly List<string> _cachedPlayerNames = new List<string>(100);
private static ZDOID _lastZDOID = ZDOID.None;
private static uint _lastDataRevision = uint.MaxValue;
private static int[] _cachedPuIdHashCodes = Array.Empty<int>();
private static int[] _cachedPuNameHashCodes = Array.Empty<int>();
public static void OptPlayerIn(PrivateArea privateArea)
{
if (!Object.op_Implicit((Object)(object)privateArea) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
PassWard.LogError("Error opting-in after password success.");
return;
}
long playerID = Player.m_localPlayer.GetPlayerID();
if (privateArea.IsPermitted(playerID))
{
ShowMessage("Already opted-in.");
return;
}
privateArea.AddPermitted(playerID, Player.m_localPlayer.GetPlayerName());
ShowMessage("Password accepted.");
Talker val = default(Talker);
if (((Component)Player.m_localPlayer).TryGetComponent<Talker>(ref val))
{
val.Say((Type)1, "[PassWard] " + privateArea.GetCreatorName() + "'s Ward: password accepted.");
}
}
public static void AddPasswordHoverText(PrivateArea privateArea, StringBuilder hoverText)
{
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
bool flag = HasPassword(privateArea);
if (privateArea.m_piece.IsCreator())
{
if (flag)
{
hoverText.Append("\n<size=18>[<color=yellow>").Append(PluginConfig.RemovePasswordKey.Value).Append("</color>] Remove password.</size>");
}
hoverText.Append("\n<size=18>[<color=yellow>").Append(PluginConfig.EnterPasswordKey.Value).Append("</color>] ")
.Append(flag ? "Change password.</size>" : "Add password.</size>");
}
else if (flag)
{
hoverText.Append("\n\n<size=18><color=green>Password enabled</color>\n[<color=yellow>").Append(PluginConfig.EnterPasswordKey.Value).Append("</color>] Enter password.</size>");
}
else
{
hoverText.Append("\n\n<size=18><color=red>No password</color></size>");
}
}
public static void EnterPassword(PrivateArea privateArea)
{
bool flag = HasPassword(privateArea);
if (privateArea.m_piece.IsCreator())
{
WardPasswordReceiver wardPasswordReceiver = new WardPasswordReceiver(privateArea);
TextInput.instance.RequestText((TextReceiver)(object)wardPasswordReceiver, flag ? "Change password" : "Set password", 32);
}
else if (!flag)
{
ShowMessage("No password assigned to this ward. Cannot opt-in using password.");
}
else
{
TryPasswordReceiver tryPasswordReceiver = new TryPasswordReceiver(privateArea);
TextInput.instance.RequestText((TextReceiver)(object)tryPasswordReceiver, "Enter password", 32);
}
}
public static void RemovePassword(PrivateArea privateArea)
{
if (!privateArea.m_piece.IsCreator())
{
ShowMessage("You do not own this ward. Cannot remove password.");
return;
}
if (!HasPassword(privateArea))
{
ShowMessage("No password on this ward to remove.");
return;
}
privateArea.m_nview.m_zdo.Set(1595635768, -1, false);
ShowMessage("Password removed.");
}
public static bool HasPassword(PrivateArea privateArea)
{
int num = default(int);
if (privateArea.m_nview.m_zdo.GetInt(1595635768, ref num))
{
return num != -1;
}
return false;
}
public static void ShowMessage(string message)
{
if (Object.op_Implicit((Object)(object)MessageHud.instance))
{
MessageHud.instance.ShowMessage((MessageType)1, message, 0, (Sprite)null, false);
}
}
public static void ClearCachedPermittedPlayerNames()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
_lastZDOID = ZDOID.None;
_lastDataRevision = uint.MaxValue;
_cachedPlayerNames.Clear();
}
public static List<string> GetCachedPermittedPlayerNames(ZDO zdo)
{
//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_0026: 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 (_lastZDOID == zdo.m_uid && _lastDataRevision == zdo.DataRevision)
{
return _cachedPlayerNames;
}
_lastZDOID = zdo.m_uid;
_lastDataRevision = zdo.DataRevision;
_cachedPlayerNames.Clear();
int num = Mathf.Max(zdo.GetInt(ZDOVars.s_permitted, 0), 0);
CachePuIdNameHashCodes(num);
for (int i = 0; i < num; i++)
{
if (zdo.GetLong(_cachedPuIdHashCodes[i], 0L) != 0L)
{
string @string = zdo.GetString(_cachedPuNameHashCodes[i], string.Empty);
if (@string.Length > 0)
{
_cachedPlayerNames.Add(@string);
}
}
}
switch (PluginConfig.WardHoverTextUserListSorting.Value)
{
case PluginConfig.UserListSorting.Alphabetically:
_cachedPlayerNames.Sort(StringComparer.OrdinalIgnoreCase);
break;
case PluginConfig.UserListSorting.ReverseAlphabetically:
_cachedPlayerNames.Sort(StringComparer.OrdinalIgnoreCase);
_cachedPlayerNames.Reverse();
break;
}
return _cachedPlayerNames;
}
private static void CachePuIdNameHashCodes(int capacity)
{
int num = Mathf.Min(_cachedPuIdHashCodes.Length, _cachedPuNameHashCodes.Length);
if (capacity > 0 && capacity >= num)
{
Array.Resize(ref _cachedPuIdHashCodes, capacity);
Array.Resize(ref _cachedPuNameHashCodes, capacity);
for (int i = num; i < capacity; i++)
{
_cachedPuIdHashCodes[i] = StringExtensionMethods.GetStableHashCode($"pu_id{i}");
_cachedPuNameHashCodes[i] = StringExtensionMethods.GetStableHashCode($"pu_name{i}");
}
}
}
}
[BepInPlugin("bruce.valheim.mods.passward", "PassWard", "1.3.0")]
public sealed class PassWard : BaseUnityPlugin
{
public const string PluginGuid = "bruce.valheim.mods.passward";
public const string PluginName = "PassWard";
public const string PluginVersion = "1.3.0";
private static ManualLogSource _logger;
private void Awake()
{
_logger = ((BaseUnityPlugin)this).Logger;
PluginConfig.BindConfig(((BaseUnityPlugin)this).Config);
Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "bruce.valheim.mods.passward");
}
public static void LogError(object obj)
{
_logger.LogError((object)$"[{DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo)}] {obj}");
}
}
[HarmonyPatch(typeof(Game))]
internal static class GamePatch
{
[HarmonyPostfix]
[HarmonyPatch("Start")]
private static void StartPostfix()
{
if (PluginConfig.IsModEnabled.Value)
{
WardManager.ClearCachedPermittedPlayerNames();
}
}
[HarmonyPrefix]
[HarmonyPatch("OnDestroy")]
private static void OnDestroyPrefix()
{
if (PluginConfig.IsModEnabled.Value)
{
WardManager.ClearCachedPermittedPlayerNames();
}
}
}
[HarmonyPatch(typeof(Player))]
internal static class PlayerPatch
{
[HarmonyTranspiler]
[HarmonyPatch("Update")]
private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Player), "UpdateHover", (Type[])null, (Type[])null), (string)null)
}).ThrowIfInvalid("Could not patch Player.Update()! (update-hover)")
.Advance(1)
.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
{
new CodeInstruction(OpCodes.Ldloc_1, (object)null),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PlayerPatch), "UpdateHoverPostDelegate", (Type[])null, (Type[])null))
})
.InstructionEnumeration();
}
private static void UpdateHoverPostDelegate(bool takeInput)
{
//IL_0021: 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)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
if (takeInput && PluginConfig.IsModEnabled.Value && Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
KeyboardShortcut value = PluginConfig.EnterPasswordKey.Value;
if (((KeyboardShortcut)(ref value)).IsDown() && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_hovering) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_hovering.TryGetComponentInParent<PrivateArea>(out PrivateArea component)))
{
WardManager.EnterPassword(component);
}
value = PluginConfig.RemovePasswordKey.Value;
if (((KeyboardShortcut)(ref value)).IsDown() && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_hovering) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_hovering.TryGetComponentInParent<PrivateArea>(out component)))
{
WardManager.RemovePassword(component);
}
}
}
public static T TryGetComponentInParent<T>(this GameObject gameObject, out T component) where T : Component
{
component = gameObject.GetComponentInParent<T>();
return component;
}
}
[HarmonyPatch(typeof(PrivateArea))]
internal static class PrivateAreaPatch
{
[HarmonyPrefix]
[HarmonyPatch("AddUserList")]
private static bool AddUserList(PrivateArea __instance, StringBuilder text)
{
if (PluginConfig.IsModEnabled.Value)
{
AddUserListUsingSeparator(__instance, text);
return false;
}
return true;
}
public static void AddUserListUsingSeparator(PrivateArea privateArea, StringBuilder text)
{
List<string> cachedPermittedPlayerNames = WardManager.GetCachedPermittedPlayerNames(privateArea.m_nview.m_zdo);
int count = cachedPermittedPlayerNames.Count;
text.Append("\n$piece_guardstone_additional: ");
if (count >= 1)
{
string value = ((PluginConfig.WardHoverTextUserListSeparator.Value == PluginConfig.UserListSeperator.Newline) ? "\n" : ", ");
text.Append(cachedPermittedPlayerNames[0]);
for (int i = 1; i < count; i++)
{
text.Append(value).Append(cachedPermittedPlayerNames[i]);
}
}
}
[HarmonyPostfix]
[HarmonyPatch("AddUserList")]
private static void AddUserListPostfix(PrivateArea __instance, StringBuilder text)
{
if (PluginConfig.IsModEnabled.Value)
{
WardManager.AddPasswordHoverText(__instance, text);
}
}
}
}
namespace ComfyLib
{
public static class ConfigFileExtensions
{
internal sealed class ConfigurationManagerAttributes
{
public Action<ConfigEntryBase> CustomDrawer;
public bool? Browsable;
public bool? HideDefaultButton;
public bool? HideSettingName;
public bool? IsAdvanced;
public int? Order;
public bool? ReadOnly;
}
private static readonly Dictionary<string, int> _sectionToSettingOrder = new Dictionary<string, int>();
private static int GetSettingOrder(string section)
{
if (!_sectionToSettingOrder.TryGetValue(section, out var value))
{
value = 0;
}
_sectionToSettingOrder[section] = value - 1;
return value;
}
public static ConfigEntry<T> BindInOrder<T>(this ConfigFile config, string section, string key, T defaultValue, string description, AcceptableValueBase acceptableValues, bool browsable = true, bool hideDefaultButton = false, bool hideSettingName = false, bool isAdvanced = false, bool readOnly = false)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
return config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, acceptableValues, new object[1]
{
new ConfigurationManagerAttributes
{
Browsable = browsable,
CustomDrawer = null,
HideDefaultButton = hideDefaultButton,
HideSettingName = hideSettingName,
IsAdvanced = isAdvanced,
Order = GetSettingOrder(section),
ReadOnly = readOnly
}
}));
}
public static ConfigEntry<T> BindInOrder<T>(this ConfigFile config, string section, string key, T defaultValue, string description, Action<ConfigEntryBase> customDrawer = null, bool browsable = true, bool hideDefaultButton = false, bool hideSettingName = false, bool isAdvanced = false, bool readOnly = false)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
return config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
{
new ConfigurationManagerAttributes
{
Browsable = browsable,
CustomDrawer = customDrawer,
HideDefaultButton = hideDefaultButton,
HideSettingName = hideSettingName,
IsAdvanced = isAdvanced,
Order = GetSettingOrder(section),
ReadOnly = readOnly
}
}));
}
public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action settingChangedHandler)
{
configEntry.SettingChanged += delegate
{
settingChangedHandler();
};
}
public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action<T> settingChangedHandler)
{
configEntry.SettingChanged += delegate(object _, EventArgs eventArgs)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
settingChangedHandler((T)((SettingChangedEventArgs)eventArgs).ChangedSetting.BoxedValue);
};
}
public static void OnSettingChanged<T>(this ConfigEntry<T> configEntry, Action<ConfigEntry<T>> settingChangedHandler)
{
configEntry.SettingChanged += delegate(object _, EventArgs eventArgs)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
settingChangedHandler((ConfigEntry<T>)((SettingChangedEventArgs)eventArgs).ChangedSetting.BoxedValue);
};
}
}
}
