using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("FastArbalest")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("FastArbalest")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9f8a1b6e-6d0e-4dab-bbd8-9ed433836544")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace neobotics.ValheimMods;
public class DelegatedConfigEntry<T> : DelegatedConfigEntryBase
{
private ConfigEntry<T> _entry;
private EventHandler rootHandler;
private Action<object, EventArgs> clientDelegate;
private Logging Log;
public ConfigEntry<T> ConfigEntry
{
get
{
return _entry;
}
set
{
_entry = value;
if (_entry != null && rootHandler != null)
{
_entry.SettingChanged += rootHandler;
}
Name = ((ConfigEntryBase)_entry).Definition.Key;
Section = ((ConfigEntryBase)_entry).Definition.Section;
ServerValue = ((ConfigEntryBase)_entry).GetSerializedValue();
Log.Trace("Set " + Section + " " + Name + " to serialized value " + ServerValue);
}
}
public T Value
{
get
{
return _entry.Value;
}
set
{
_entry.Value = value;
}
}
public DelegatedConfigEntry(bool useServerDelegate = false)
: this((Action<object, EventArgs>)null, useServerDelegate)
{
}
public DelegatedConfigEntry(Action<object, EventArgs> delegateHandler, bool useServerDelegate = false)
{
Log = Logging.GetLogger();
Log.Trace("DelegatedConfigEntry");
if (delegateHandler != null)
{
clientDelegate = delegateHandler;
}
if (useServerDelegate)
{
Log.Trace("Configuring server delegate");
rootHandler = delegate(object s, EventArgs e)
{
ServerDelegate(s, e);
};
ServerConfiguration.ServerDelegatedEntries.Add(this);
}
else if (clientDelegate != null)
{
rootHandler = delegate(object s, EventArgs e)
{
clientDelegate(s, e);
};
}
}
private void ServerDelegate(object sender, EventArgs args)
{
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Expected O, but got Unknown
Logging.GetLogger().Trace("ServerDelegate");
_entry.SettingChanged -= rootHandler;
ZNet instance = ZNet.instance;
bool? flag = ((instance != null) ? new bool?(instance.IsServer()) : null);
if (flag.HasValue)
{
if (flag == false && ServerConfiguration.Instance.ReceivedServerValues)
{
if (ServerValue != null)
{
((ConfigEntryBase)_entry).SetSerializedValue(ServerValue);
Log.Debug("Setting " + Name + " to server value " + ServerValue);
}
}
else if (flag == true)
{
ServerValue = ((ConfigEntryBase)_entry).GetSerializedValue();
ServerConfiguration.Instance.SendConfigToAllClients(sender, (SettingChangedEventArgs)args);
}
}
if (clientDelegate != null)
{
clientDelegate(sender, args);
}
_entry.SettingChanged += rootHandler;
}
public void EnableHandler(bool setActive)
{
if (setActive)
{
_entry.SettingChanged += rootHandler;
}
else
{
_entry.SettingChanged -= rootHandler;
}
}
public bool IsKeyPressed()
{
//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_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
if (ConfigEntry is ConfigEntry<KeyboardShortcut> val)
{
KeyboardShortcut value = val.Value;
foreach (KeyCode modifier in ((KeyboardShortcut)(ref value)).Modifiers)
{
if (!Input.GetKey(modifier))
{
return false;
}
}
if (!Input.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey))
{
return false;
}
return true;
}
Log.Error("Keyboard read attempted on non-KeyboardShortcut config.");
return false;
}
public bool IsKeyDown()
{
//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_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
if (ConfigEntry is ConfigEntry<KeyboardShortcut> val)
{
KeyboardShortcut value = val.Value;
foreach (KeyCode modifier in ((KeyboardShortcut)(ref value)).Modifiers)
{
if (!Input.GetKey(modifier))
{
return false;
}
}
if (!Input.GetKey(((KeyboardShortcut)(ref value)).MainKey))
{
return false;
}
return true;
}
Log.Error("Keyboard read attempted on non-KeyboardShortcut config.");
return false;
}
public bool IsKeyReleased()
{
//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_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
if (ConfigEntry is ConfigEntry<KeyboardShortcut> val)
{
KeyboardShortcut value = val.Value;
foreach (KeyCode modifier in ((KeyboardShortcut)(ref value)).Modifiers)
{
if (!Input.GetKeyUp(modifier))
{
return false;
}
}
if (!Input.GetKeyUp(((KeyboardShortcut)(ref value)).MainKey))
{
return false;
}
return true;
}
Log.Error("Keyboard read attempted on non-KeyboardShortcut config.");
return false;
}
}
public class DelegatedConfigEntryBase
{
public string Name;
public string Section;
public string ServerValue;
}
public class Logging
{
public enum LogLevels
{
Critical,
Error,
Warning,
Info,
Debug,
Trace
}
private static Logging _logger;
public LogLevels LogLevel { get; set; }
public string ModName { get; set; }
private Logging(LogLevels level, string name)
{
LogLevel = level;
ModName = name;
}
public static Logging GetLogger(LogLevels level, string name)
{
if (_logger == null)
{
_logger = new Logging(level, name);
}
return _logger;
}
public static Logging GetLogger()
{
if (_logger == null)
{
throw new NullReferenceException("Logger not initialized");
}
return _logger;
}
public void Trace(string msg)
{
if (LogLevel >= LogLevels.Trace)
{
Debug.Log((object)Message(msg));
}
}
public void Debug(string msg)
{
if (LogLevel >= LogLevels.Debug)
{
Debug.Log((object)Message(msg));
}
}
public void Info(string msg)
{
if (LogLevel >= LogLevels.Info)
{
Debug.Log((object)Message(msg));
}
}
public void Warning(string msg)
{
if (LogLevel >= LogLevels.Warning)
{
Debug.LogWarning((object)Message(msg));
}
}
public void Error(string msg)
{
if (LogLevel >= LogLevels.Error)
{
Debug.LogWarning((object)Message(msg));
}
}
public void Error(Exception e)
{
Error(e, stackTrace: false);
}
public void Error(Exception e, bool stackTrace)
{
if (LogLevel >= LogLevels.Error)
{
Warning(Message(e.Message));
if (stackTrace)
{
Warning(e.StackTrace);
}
}
}
public void Critical(Exception e)
{
if (LogLevel >= LogLevels.Critical)
{
Debug(Message(e.Message));
Error(e.StackTrace);
}
}
private string Message(string msg)
{
return ModName + ": " + msg;
}
public static void ChangeLogging(object s, EventArgs e)
{
SettingChangedEventArgs val = (SettingChangedEventArgs)(object)((e is SettingChangedEventArgs) ? e : null);
GetLogger().Debug($"ChangeLog {val.ChangedSetting.Definition.Key} to {val.ChangedSetting.BoxedValue}");
GetLogger().LogLevel = Cfg.debugLevel.Value;
}
}
public class ServerConfiguration
{
[HarmonyPatch(typeof(ZNet), "StopAll")]
private static class ZNet_Shutdown_Patch
{
[HarmonyPrefix]
private static void ZNet_StopAll_Prefix(ZNet __instance)
{
Log.Debug("ZNet_StopAll_Patch_Prefix");
if (Instance != null)
{
Instance.ReceivedServerValues = false;
}
}
}
[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
private static class ZNet_OnNewConnection_Patch
{
private static void Postfix(ZNet __instance, ZNetPeer peer)
{
Log.Debug("ZNet OnNewConnection postfix");
if (!__instance.IsServer())
{
try
{
peer.m_rpc.Register<ZPackage>("ClientConfigReceiver." + GetPluginGuid(), (Action<ZRpc, ZPackage>)Instance.RPC_ClientConfigReceiver);
Log.Debug("Player registered RPC_ClientConfigReceiver");
return;
}
catch (Exception)
{
Log.Warning("Failed to register RPC");
return;
}
}
try
{
Instance.SendConfigToClient(peer);
}
catch (Exception)
{
Log.Warning("Error sending server configuration to client");
}
}
}
public static List<DelegatedConfigEntryBase> ServerDelegatedEntries = new List<DelegatedConfigEntryBase>();
private static ConfigFile LocalConfig;
private static BaseUnityPlugin Mod;
private static string ConfigFileName;
private static ServerConfiguration _instance;
private static Logging Log;
public bool IsSetup;
public bool ReceivedServerValues;
public FileSystemWatcher ConfigWatcher;
private const string NOT_CONFIGURED = "ServerConfiguration not initialized. Setup first.";
public static ServerConfiguration Instance
{
get
{
if (_instance == null)
{
_instance = new ServerConfiguration();
}
return _instance;
}
}
private ServerConfiguration()
{
}
public void Setup(ConfigFile config, BaseUnityPlugin modInstance)
{
LocalConfig = config;
Log = Logging.GetLogger();
Log.Trace("ServerConfiguration Setup");
Mod = modInstance;
ConfigFileName = Path.GetFileName(LocalConfig.ConfigFilePath);
IsSetup = true;
}
public void CreateConfigWatcher()
{
ConfigWatcher = Utils.CreateFileWatcher(LocalConfig.ConfigFilePath, LoadConfig);
}
private void LoadConfig(object sender, FileSystemEventArgs e)
{
if (!File.Exists(LocalConfig.ConfigFilePath))
{
return;
}
try
{
Log.Debug($"Loading configuration {e.ChangeType}");
LocalConfig.Reload();
}
catch
{
Log.Error("Error loading configuration file " + ConfigFileName);
}
}
public static string GetPluginGuid()
{
return Mod.Info.Metadata.GUID;
}
public void RPC_ClientConfigReceiver(ZRpc zrpc, ZPackage package)
{
if (!Instance.IsSetup)
{
Log.Error("ServerConfiguration not initialized. Setup first.");
return;
}
Log.Debug("ClientConfigReceiver");
string section;
string name;
while (package.GetPos() < package.Size())
{
section = package.ReadString();
name = package.ReadString();
string text = package.ReadString();
Log.Trace("Reading " + section + " " + name + " value " + text + " from ZPackage");
DelegatedConfigEntryBase delegatedConfigEntryBase = ServerDelegatedEntries.Find((DelegatedConfigEntryBase e) => e.Name == name && e.Section == section);
if (delegatedConfigEntryBase != null)
{
Log.Trace("Found DCEB on client and setting to server value " + text);
delegatedConfigEntryBase.ServerValue = text;
}
ConfigEntryBase val = LocalConfig[section, name];
if (val != null)
{
Log.Trace("Found local CEB and setting underlying config value " + text);
val.SetSerializedValue(text);
}
}
ReceivedServerValues = true;
}
internal void WriteConfigEntries(ZPackage zpkg)
{
foreach (DelegatedConfigEntryBase serverDelegatedEntry in ServerDelegatedEntries)
{
Log.Trace("Writing " + serverDelegatedEntry.Section + " " + serverDelegatedEntry.Name + " value " + serverDelegatedEntry.ServerValue + " to ZPackage");
zpkg.Write(serverDelegatedEntry.Section);
zpkg.Write(serverDelegatedEntry.Name);
zpkg.Write(serverDelegatedEntry.ServerValue);
}
}
internal void SendConfigToClient(ZNetPeer peer)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
if (!Instance.IsSetup)
{
Log.Error("ServerConfiguration not initialized. Setup first.");
return;
}
Log.Debug("SendConfigToClient");
ZPackage val = new ZPackage();
WriteConfigEntries(val);
peer.m_rpc.Invoke("ClientConfigReceiver." + GetPluginGuid(), new object[1] { val });
Log.Trace("Invoked ClientConfigReceiver on peer");
}
public void SendConfigToAllClients(object o, SettingChangedEventArgs e)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Expected O, but got Unknown
if (!IsSetup)
{
Log.Error("ServerConfiguration not initialized. Setup first.");
}
else if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && ZNet.instance.GetPeerConnections() > 0)
{
Log.Debug("SendConfigToAllClients");
ZPackage zpkg = new ZPackage();
WriteConfigEntries(zpkg);
((MonoBehaviour)Mod).StartCoroutine(_instance.Co_BroadcastConfig(zpkg));
}
}
private IEnumerator Co_BroadcastConfig(ZPackage zpkg)
{
Log.Debug("Co_BroadcastConfig");
List<ZNetPeer> connectedPeers = ZNet.instance.GetConnectedPeers();
foreach (ZNetPeer item in connectedPeers)
{
if (item != ZNet.instance.GetServerPeer())
{
item.m_rpc.Invoke("ClientConfigReceiver." + GetPluginGuid(), new object[1] { zpkg });
Log.Trace("Invoked ClientConfigReceiver on peer");
}
yield return null;
}
}
}
internal class Utils
{
public static TEnum Guardrails<TEnum>(string value, TEnum enumDefault) where TEnum : struct
{
if (Enum.TryParse<TEnum>(value, ignoreCase: true, out var result))
{
return result;
}
return enumDefault;
}
public static int Guardrails(int value, int lbound, int ubound)
{
if (value < lbound)
{
return lbound;
}
if (value > ubound)
{
return ubound;
}
return value;
}
public static string truncate(string value, int maxChars)
{
if (value == null)
{
return null;
}
if (value.Length <= maxChars)
{
return value;
}
return value.Substring(0, maxChars);
}
public static void GetCharactersInRangeXZ(Vector3 point, float radius, List<Character> characters)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
float num = radius * radius;
foreach (Character s_character in Character.s_characters)
{
if (DistanceSqrXZ(((Component)s_character).transform.position, point) < num)
{
characters.Add(s_character);
}
}
}
public static float DistanceSqr(Vector3 v0, Vector3 v1)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
float num = v1.x - v0.x;
float num2 = v1.y - v0.y;
float num3 = v1.z - v0.z;
return num * num + num2 * num2 + num3 * num3;
}
public static float DistanceSqrXZ(Vector3 v0, Vector3 v1)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
float num = v1.x - v0.x;
float num2 = v1.z - v0.z;
return num * num + num2 * num2;
}
public static float DistanceXZ(Vector3 v0, Vector3 v1)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
float num = v1.x - v0.x;
float num2 = v1.z - v0.z;
return Mathf.Sqrt(num * num + num2 * num2);
}
public static float Guardrails(float value, float lbound, float ubound)
{
if (value < lbound)
{
return lbound;
}
if (value > ubound)
{
return ubound;
}
return value;
}
public static string UnClonifiedName(string name)
{
if (name == null)
{
return null;
}
int num = name.IndexOf("(Clone)");
if (num < 1)
{
return name;
}
return name.Substring(0, num);
}
public static void SetTranslator(int id, string idText)
{
typeof(Localization).GetMethod("AddWord", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(Localization.instance, new object[2]
{
"skill_" + id,
idText
});
}
public static string GetTranslated(int id)
{
Logging.GetLogger().Debug(string.Format("Got translation for id {0} to {1}", id, Localization.instance.Localize("skill_" + id)));
return Localization.instance.Localize("$skill_" + id);
}
public static string GetAssemblyPathedFile(string fileName)
{
return new FileInfo(Assembly.GetExecutingAssembly().Location).DirectoryName.Replace('\\', '/') + "/" + fileName;
}
public static Sprite GetPrefabIcon(string prefabName)
{
Sprite result = null;
GameObject prefab = GetPrefab(prefabName);
ItemDrop val = default(ItemDrop);
if ((Object)(object)prefab != (Object)null && prefab.TryGetComponent<ItemDrop>(ref val))
{
result = val.m_itemData.GetIcon();
}
return result;
}
public static Player GetPlayerByZDOID(ZDOID zid)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
foreach (Player allPlayer in Player.GetAllPlayers())
{
ZDOID zDOID = ((Character)allPlayer).GetZDOID();
if (((ZDOID)(ref zDOID)).Equals(zid))
{
return allPlayer;
}
}
return null;
}
public static Character GetCharacterByZDOID(string cid)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
foreach (Character allCharacter in Character.GetAllCharacters())
{
ZDOID zDOID = allCharacter.GetZDOID();
if (((object)(ZDOID)(ref zDOID)).ToString().Equals(cid))
{
return allCharacter;
}
}
return null;
}
public static Character GetCharacterByZDOID(ZDOID cid)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
foreach (Character allCharacter in Character.GetAllCharacters())
{
ZDOID zDOID = allCharacter.GetZDOID();
if (((ZDOID)(ref zDOID)).Equals(cid))
{
return allCharacter;
}
}
return null;
}
public static ZNetPeer GetPeerByRPC(ZRpc rpc)
{
foreach (ZNetPeer peer in ZNet.instance.GetPeers())
{
if (peer.m_rpc == rpc)
{
return peer;
}
}
return null;
}
public static List<GameObject> GetGameObjectsOfType(Type t)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
List<GameObject> list = new List<GameObject>();
Object[] array = Object.FindObjectsOfType(t);
foreach (Object val in array)
{
list.Add(((Component)val).gameObject);
}
return list;
}
public static GameObject GetClosestGameObjectOfType(Type t, Vector3 point, float radius)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return GetGameObjectsOfTypeInRangeByDistance(t, point, radius)?[0];
}
public static List<GameObject> GetGameObjectsOfTypeInRangeByDistance(Type t, Vector3 point, float radius)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
List<KeyValuePair<GameObject, float>> list = new List<KeyValuePair<GameObject, float>>();
List<GameObject> gameObjectsOfTypeInRange = GetGameObjectsOfTypeInRange(t, point, radius);
if (gameObjectsOfTypeInRange.Count > 0)
{
foreach (GameObject item in gameObjectsOfTypeInRange)
{
list.Add(new KeyValuePair<GameObject, float>(item, Vector3.Distance(item.transform.position, point)));
}
list.Sort((KeyValuePair<GameObject, float> pair1, KeyValuePair<GameObject, float> pair2) => pair1.Value.CompareTo(pair2.Value));
return list.ConvertAll((KeyValuePair<GameObject, float> x) => x.Key);
}
return null;
}
public static List<GameObject> GetGameObjectsOfTypeInRange(Type t, Vector3 point, float radius)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
return (from x in GetGameObjectsOfType(t)
where Vector3.Distance(x.transform.position, point) < radius
select x).ToList();
}
public static float GetPointDepth(Vector3 p)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
return ZoneSystem.instance.m_waterLevel - GetSolidHeight(p);
}
public static List<string> GetDelimitedStringAsList(string delimitedString, char delimiter)
{
List<string> list = new List<string>();
string[] array = delimitedString.Split(new char[1] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
foreach (string text in array)
{
list.Add(text.Trim());
}
return list;
}
public static float GetSolidHeight(Vector3 p)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
int solidRayMask = ZoneSystem.instance.m_solidRayMask;
float result = 0f;
p.y += 1000f;
RaycastHit val = default(RaycastHit);
if (Physics.Raycast(p, Vector3.down, ref val, 2000f, solidRayMask) && !Object.op_Implicit((Object)(object)((RaycastHit)(ref val)).collider.attachedRigidbody))
{
result = ((RaycastHit)(ref val)).point.y;
}
return result;
}
public static Transform FindChild(Transform aParent, string aName)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
foreach (Transform item in aParent)
{
Transform val = item;
if (((Object)val).name == aName)
{
return val;
}
Transform val2 = FindChild(val, aName);
if ((Object)(object)val2 != (Object)null)
{
return val2;
}
}
return null;
}
public static Transform FindParent(Transform go)
{
while ((Object)(object)go.parent != (Object)null)
{
go = go.parent;
}
return go;
}
public static GameObject GetPrefab(int prefabHash)
{
return GetPrefabByHash(prefabHash);
}
public static GameObject GetPrefabByHash(int prefabHash)
{
GameObject val = ObjectDB.instance.GetItemPrefab(prefabHash);
Logging logger = Logging.GetLogger();
if ((Object)(object)val != (Object)null)
{
logger.Debug("Found prefab in ObjectDB");
}
else
{
ZNetScene instance = ZNetScene.instance;
val = ((instance != null) ? instance.GetPrefab(prefabHash) : null);
if ((Object)(object)val != (Object)null)
{
logger.Debug("Found prefab in Scene");
}
}
return val;
}
public static GameObject GetPrefab(string prefabName)
{
GameObject val = ObjectDB.instance.GetItemPrefab(prefabName);
Logging logger = Logging.GetLogger();
if ((Object)(object)val != (Object)null)
{
logger.Debug("Found " + prefabName + " in ObjectDB");
}
else
{
ZNetScene instance = ZNetScene.instance;
val = ((instance != null) ? instance.GetPrefab(prefabName) : null);
if ((Object)(object)val != (Object)null)
{
logger.Debug("Found " + prefabName + " in Scene");
}
}
return val;
}
public static string SerializeFromDictionary<K, V>(string delimp, string delimc, IDictionary<K, V> dict)
{
if (dict == null)
{
return null;
}
IEnumerable<string> values = dict.Select(delegate(KeyValuePair<K, V> kvp)
{
KeyValuePair<K, V> keyValuePair = kvp;
string? obj = keyValuePair.Key?.ToString();
string text = delimc;
keyValuePair = kvp;
return obj + text + keyValuePair.Value;
});
return string.Join(delimp, values);
}
public static void DeserializeToDictionary<K, V>(string serializedString, string delimp, string delimc, ref IDictionary<K, V> dict)
{
if (dict == null)
{
return;
}
dict.Clear();
string[] separator = new string[1] { delimp };
string[] separator2 = new string[1] { delimc };
string[] array = serializedString.Split(separator, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < array.Length; i++)
{
string[] array2 = array[i].Split(separator2, StringSplitOptions.RemoveEmptyEntries);
if (array2.Length == 2)
{
dict.Add(TypedValue<K>(array2[0]), TypedValue<V>(array2[1]));
}
}
}
public static FileSystemWatcher CreateFileWatcher(string fullPath, FileSystemEventHandler handler)
{
string fileName = Path.GetFileName(fullPath);
FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(fullPath.Substring(0, fullPath.Length - fileName.Length), fileName);
fileSystemWatcher.NotifyFilter = NotifyFilters.Attributes | NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.CreationTime;
fileSystemWatcher.Changed += handler;
fileSystemWatcher.Created += handler;
fileSystemWatcher.IncludeSubdirectories = false;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
return fileSystemWatcher;
}
public static T TypedValue<T>(object a)
{
return (T)Convert.ChangeType(a, typeof(T));
}
public static float TimeAdjustedRamp(float maxValue, float duration, float elapsedTime, float pctFromStartRise, float pctFromEndFall)
{
float num = elapsedTime / duration;
if (num <= pctFromStartRise)
{
return maxValue * (num / pctFromStartRise);
}
if (num >= 1f - pctFromEndFall)
{
return maxValue * ((1f - num) / pctFromEndFall);
}
return maxValue;
}
public static bool CopyComponentToGameObject(Component original, ref GameObject destination)
{
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
Logging logger = Logging.GetLogger();
Type type = ((object)original).GetType();
logger.Debug($"Original Type is {type}");
GameObject obj = destination;
logger.Debug("Destination GameObject " + ((obj != null) ? ((Object)obj).name : null));
Component val = destination.GetComponent(type);
if ((Object)(object)val == (Object)null)
{
val = destination.AddComponent(type);
}
if ((Object)(object)val == (Object)null)
{
logger.Debug("Destination component is null");
return false;
}
Component val2 = (Component)Activator.CreateInstance(type);
if ((Object)(object)val2 == (Object)null)
{
logger.Debug("Destination component is null");
return false;
}
if ((Object)(object)val2 == (Object)null)
{
logger.Debug("Boxed component is null");
return false;
}
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo fieldInfo in fields)
{
fieldInfo.SetValue(val2, fieldInfo.GetValue(original));
}
val = val2;
return true;
}
public static bool CopyObject(object original, object target)
{
Logging logger = Logging.GetLogger();
Type type = original.GetType();
Type type2 = target.GetType();
if (type == null)
{
logger.Warning("Copy Object: Source object is null");
Activator.CreateInstance(type);
return false;
}
if (type2 == null)
{
logger.Warning("Copy Object: Destination object is null");
return false;
}
if (type2 != type)
{
logger.Warning("Copy Object: Source and destination components are different types");
return false;
}
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo fieldInfo in fields)
{
fieldInfo.SetValue(target, fieldInfo.GetValue(original));
}
return true;
}
}
internal class Cfg
{
public static DelegatedConfigEntry<bool> proportionalDamage = null;
public static DelegatedConfigEntry<int> reloadSpeed = null;
public static DelegatedConfigEntry<bool> reloadPause = null;
public static DelegatedConfigEntry<bool> slingLoaded = null;
public static DelegatedConfigEntry<bool> realisticRecoil = null;
public static DelegatedConfigEntry<bool> realisticKnockback = null;
public static DelegatedConfigEntry<Logging.LogLevels> debugLevel = null;
private static KeyCode[] keyModifiers = (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 };
public static KeyboardShortcut keyConfigItemDefault = new KeyboardShortcut((KeyCode)116, keyModifiers);
public static void BepInExConfig(BaseUnityPlugin _instance)
{
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Expected O, but got Unknown
debugLevel = new DelegatedConfigEntry<Logging.LogLevels>(Logging.ChangeLogging);
debugLevel.ConfigEntry = _instance.Config.Bind<Logging.LogLevels>("Utility", "LogLevel", Logging.LogLevels.Info, "Controls the level of information contained in the log");
FastArbalest.Log.LogLevel = debugLevel.Value;
proportionalDamage = new DelegatedConfigEntry<bool>(useServerDelegate: true);
proportionalDamage.ConfigEntry = _instance.Config.Bind<bool>("General", "Proportional Damage", true, "Reduces damage proportionaly to the Reload Rate to maintain DPS, e.g. a 50% reload time results in 50% of full damage. Also reduces recoil by the same proportion.@");
reloadSpeed = new DelegatedConfigEntry<int>(useServerDelegate: true);
reloadSpeed.ConfigEntry = _instance.Config.Bind<int>("General", "Reload Rate", 100, new ConfigDescription("Percentage of 'normal' time to reload the Crossbow, from 10 to 100, e.g. 50 is 50% of the reload time of a 'regular' Crossbow.@", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 100), Array.Empty<object>()));
reloadPause = new DelegatedConfigEntry<bool>(useServerDelegate: true);
reloadPause.ConfigEntry = _instance.Config.Bind<bool>("General", "Pausable Reload", false, "Pauses reload action when running, jumping or dodging, rather than restarting it.@");
slingLoaded = new DelegatedConfigEntry<bool>(useServerDelegate: true);
slingLoaded.ConfigEntry = _instance.Config.Bind<bool>("General", "Sling Loaded", false, "Allows slinging a crossbow on your back (show/hide or swim) while loaded. Unslinging does not require a reload before use.@");
realisticRecoil = new DelegatedConfigEntry<bool>(useServerDelegate: true);
realisticRecoil.ConfigEntry = _instance.Config.Bind<bool>("Realism", "Realistic Recoil", false, "Removes recoil (except for a small jolt), in line with the actual physics of a crossbow.@");
realisticKnockback = new DelegatedConfigEntry<bool>(useServerDelegate: true);
realisticKnockback.ConfigEntry = _instance.Config.Bind<bool>("Realism", "Realistic Knockback", false, "Adjusts Valheim's Arbalest 'knockback' to be more in line with a sharp piercing weapon.@");
}
}
[BepInPlugin("neobotics.valheim_mod.fastarbalest", "FastArbalest", "0.1.7")]
[BepInProcess("valheim.exe")]
[BepInProcess("valheim_server.exe")]
public class FastArbalest : BaseUnityPlugin
{
public enum BypassableAction
{
None,
Running,
Jumping,
Dodging
}
[HarmonyPatch(typeof(Humanoid), "EquipItem")]
private static class Humanoid_EquipItem_Patch
{
[HarmonyPrefix]
private static void Humanoid_EquipItem_Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects)
{
if (__instance is Player && (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
{
backLeftWeaponLoaded = false;
}
}
}
[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
private static class Humanoid_UnequipItem_Patch
{
[HarmonyPrefix]
private static void Humanoid_UnequipItem_Prefix(Humanoid __instance)
{
if (__instance is Player && (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
{
backLeftWeaponLoaded = false;
}
}
}
[HarmonyPatch(typeof(Humanoid), "ShowHandItems")]
private static class Humanoid_ShowHandItems_Patch
{
[HarmonyPrefix]
private static void Humanoid_ShowHandItems_Prefix(Humanoid __instance, ref bool __state)
{
Log.Debug("Humanoid_ShowHandItems_Patch_Prefix");
__state = backLeftWeaponLoaded;
}
[HarmonyPostfix]
private static void Humanoid_ShowHandItems_Postfix(Humanoid __instance, ref bool __state)
{
backLeftWeaponLoaded = __state;
}
}
[HarmonyPatch(typeof(Humanoid), "HideHandItems")]
private static class Humanoid_HideHandItems_Patch
{
[HarmonyPrefix]
private static void Humanoid_HideHandItems_Prefix(Humanoid __instance, ref bool __state)
{
Log.Debug("Humanoid_HideHandItems_Patch_Prefix");
__state = backLeftWeaponLoaded;
}
[HarmonyPostfix]
private static void Humanoid_HideHandItems_Postfix(Humanoid __instance, ref bool __state)
{
backLeftWeaponLoaded = __state;
}
}
[HarmonyPatch(typeof(Attack), "ProjectileAttackTriggered")]
private static class Attack_ProjectileAttackTriggered_Patch
{
[HarmonyPrefix]
private static void Attack_ProjectileAttackTriggered_Prefix(Attack __instance)
{
Log.Debug("Attack_ProjectileAttackTriggered_Patch_Prefix");
backLeftWeaponLoaded = false;
}
}
[HarmonyPatch(typeof(Player), "SetWeaponLoaded")]
private static class Player_SetWeaponLoaded_Patch
{
[HarmonyPostfix]
private static void Player_SetWeaponLoaded_Postfix(Player __instance, ItemData weapon)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Invalid comparison between Unknown and I4
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Invalid comparison between Unknown and I4
if (weapon != null && Cfg.slingLoaded.Value)
{
if ((int)weapon.m_shared.m_skillType == 14)
{
Log.Debug("Setting crossbow loaded");
backLeftWeaponLoaded = true;
}
else if ((int)weapon.m_shared.m_skillType == 9 && chargeableStaffs.Contains(((Object)weapon.m_dropPrefab).name))
{
Log.Debug("Setting staff charged");
backLeftWeaponLoaded = true;
}
}
}
}
[HarmonyPatch(typeof(ItemData), "GetWeaponLoadingTime")]
private static class ItemData_GetWeaponLoadingTime_Patch
{
private static void Prefix(ItemData __instance)
{
if (originalReloadTime < 0f)
{
originalReloadTime = __instance.m_shared.m_attack.m_reloadTime;
}
if (backLeftWeaponLoaded)
{
Log.Debug("Crossbow already loaded");
__instance.m_shared.m_attack.m_reloadTime = 0.25f;
}
else
{
Log.Debug($"Reload time {__instance.m_shared.m_attack.m_reloadTime}");
__instance.m_shared.m_attack.m_reloadTime = originalReloadTime * ((float)Cfg.reloadSpeed.Value / 100f);
}
}
}
[HarmonyPatch(typeof(Attack), "OnAttackTrigger")]
private static class Attack_OnAttackTrigger_Patch
{
[HarmonyPrefix]
private static void Attack_OnAttackTrigger_Prefix(Attack __instance)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Invalid comparison between Unknown and I4
Log.Debug("Attack_OnAttackTrigger_Patch_Prefix");
if ((Object)(object)__instance.m_character == (Object)(object)Player.m_localPlayer && (int)__instance.m_weapon.m_shared.m_skillType == 14)
{
if (Cfg.realisticRecoil.Value)
{
__instance.m_recoilPushback *= 0.1f;
}
else if (Cfg.proportionalDamage.Value)
{
float num = (float)Cfg.reloadSpeed.Value / 100f;
__instance.m_recoilPushback *= num;
__instance.m_forceMultiplier *= num;
__instance.m_staggerMultiplier *= num;
}
if (Cfg.realisticKnockback.Value)
{
__instance.m_forceMultiplier /= 3f;
__instance.m_staggerMultiplier /= 2f;
}
}
}
}
[HarmonyPatch(typeof(SEMan), "ModifyAttack")]
private static class SEMan_ModifyAttack_Patch
{
private static void Postfix(SEMan __instance, SkillType skill, ref HitData hitData)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Invalid comparison between Unknown and I4
Log.Trace("SEMan_ModifyAttack_Patch prefix");
if ((Object)(object)__instance.m_character == (Object)(object)Player.m_localPlayer && Cfg.proportionalDamage.Value)
{
Character character = __instance.m_character;
ItemData weapon = ((Humanoid)((character is Player) ? character : null)).m_currentAttack.GetWeapon();
if ((int)skill == 14 || weapon.m_shared.m_name == "$item_staff_lightning")
{
((DamageTypes)(ref hitData.m_damage)).Modify((float)Cfg.reloadSpeed.Value / 100f);
Log.Debug("Damage modified");
}
}
}
}
[HarmonyPatch(typeof(Player), "UpdateActionQueue")]
private static class Player_UpdateActionQueue_Patch
{
[HarmonyPrefix]
private static void Player_UpdateActionQueue_Prefix(Player __instance, float dt)
{
if (Cfg.reloadPause.Value && isPlayerReloading(__instance) && !((Character)__instance).IsOnGround())
{
Log.Trace("Pausing reload while landing");
__instance.m_actionQueuePause = 0.5f;
}
}
}
[HarmonyPatch(typeof(Player), "CheckRun")]
private static class Player_CheckRun_Patch
{
[HarmonyPrefix]
private static void Player_CheckRun_Prefix(Player __instance)
{
if (((Character)__instance).m_run && Cfg.reloadPause.Value && isPlayerReloading(__instance))
{
Log.Trace("Pausing reload on run");
bypassAction = BypassableAction.Running;
__instance.m_actionQueuePause = 0.5f;
}
}
[HarmonyPostfix]
private static void Player_CheckRun_Postfix(Player __instance)
{
bypassAction = BypassableAction.None;
}
}
[HarmonyPatch(typeof(Player), "ClearActionQueue")]
private static class Player_ClearActionQueue_Patch
{
[HarmonyPrefix]
private static bool Player_ClearActionQueue_Prefix(Player __instance)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Invalid comparison between Unknown and I4
if (!Cfg.reloadPause.Value || bypassAction == BypassableAction.None)
{
return true;
}
Log.Trace("Overriding ClearActionQueue to keep reload");
foreach (MinorActionData item in __instance.m_actionQueue)
{
if ((int)item.m_type != 2)
{
__instance.m_actionQueue.Remove(item);
break;
}
}
return false;
}
}
[HarmonyPatch(typeof(Player), "OnJump")]
private static class Player_OnJump_Patch
{
[HarmonyPrefix]
private static void Player_OnJump_Prefix(Player __instance)
{
Log.Debug("Player_OnJump_Patch_Prefix");
if (Cfg.reloadPause.Value && isPlayerReloading(__instance))
{
Log.Debug("Pausing reload on jump");
bypassAction = BypassableAction.Jumping;
__instance.m_actionQueuePause += 1.5f;
}
}
[HarmonyPostfix]
private static void Player_OnJump_Postfix(Player __instance)
{
bypassAction = BypassableAction.None;
}
}
[HarmonyPatch(typeof(Player), "UpdateDodge")]
private static class Player_UpdateDodge_Patch
{
[HarmonyPrefix]
private static void Player_UpdateDodge_Prefix(Player __instance)
{
if (Cfg.reloadPause.Value && __instance.m_queuedDodgeTimer > 0f && isPlayerReloading(__instance))
{
Log.Debug("Pausing reload on dodge");
bypassAction = BypassableAction.Dodging;
__instance.m_actionQueuePause = 1.5f;
}
}
[HarmonyPostfix]
private static void Player_UpdateDodge_Postfix(Player __instance)
{
bypassAction = BypassableAction.None;
}
}
private static FastArbalest _modInstance;
private static string Mod = "FastArbalest";
private static string LcMod = Mod.ToLower();
public static Logging Log;
public static string UNIQUE_ID = Mod + "_1847_";
public static List<string> chargeableStaffs = new List<string> { "StaffLightning" };
private static float originalReloadTime = -1f;
private static BypassableAction bypassAction = BypassableAction.None;
private static bool backRightWeaponLoaded = false;
private static bool backLeftWeaponLoaded = false;
private Harmony harmony;
public static DelegatedConfigEntry<Logging.LogLevels> debugLevel = null;
public static FastArbalest GetInstance()
{
return _modInstance;
}
private void Awake()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
_modInstance = this;
harmony = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
harmony.PatchAll(Assembly.GetExecutingAssembly());
ConfigureMod();
Log.Info("Awake");
}
private void ConfigureMod()
{
Log = Logging.GetLogger(Logging.LogLevels.Info, Mod);
ServerConfiguration.Instance.Setup(((BaseUnityPlugin)this).Config, (BaseUnityPlugin)(object)_modInstance);
Cfg.BepInExConfig((BaseUnityPlugin)(object)_modInstance);
ServerConfiguration.Instance.CreateConfigWatcher();
}
private void OnDestroy()
{
harmony.UnpatchSelf();
}
private static bool isPlayerReloading(Player player)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Invalid comparison between Unknown and I4
if (player.m_actionQueue != null && player.m_actionQueue.Count > 0)
{
return (int)player.m_actionQueue[0].m_type == 2;
}
return false;
}
}
