using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
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 BepInEx.Logging;
using FishNet.Object;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("SeaLegs")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Azumatt")]
[assembly: AssemblyProduct("SeaLegs")]
[assembly: AssemblyCopyright("Copyright © 2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("B24BE9E0-1351-4951-AE19-B645B64CA6C5")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[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;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class ExtensionMarkerAttribute : Attribute
{
public ExtensionMarkerAttribute(string name)
{
}
}
}
namespace SeaLegs
{
internal sealed class LocalBodyDriver : MonoBehaviour
{
private Player _player;
private OtherPlayer _other;
private bool _wasOnBoat;
internal void Init(Player player)
{
_player = player;
_other = player.Other;
_wasOnBoat = player.Movement.OnBoat;
Sync();
}
private void Update()
{
if (Object.op_Implicit((Object)(object)_player) && Object.op_Implicit((Object)(object)_other) && SeaLegsPlugin.IsEnabled)
{
Sync();
}
}
private void Sync()
{
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: 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)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)_player.CamObject) && Object.op_Implicit((Object)(object)_player.Transform) && Object.op_Implicit((Object)(object)_other._transform))
{
bool onBoat = _player.Movement.OnBoat;
if (onBoat != _wasOnBoat)
{
_wasOnBoat = onBoat;
ClearVelSamples();
}
_other.OnBoat = onBoat;
Vector3 localEulerAngles = _player.CamObject.localEulerAngles;
Quaternion val = Quaternion.Euler(0f, localEulerAngles.y, 0f);
_other._transform.position = _player.Transform.position + val * SeaLegsPlugin.BodyOffset;
_other._transform.rotation = val;
_other._camProxy.localRotation = Quaternion.Euler(localEulerAngles.x, 0f, 0f);
}
}
private void ClearVelSamples()
{
_other._velSamples.Clear();
}
}
internal sealed class ShadowHeadFollow : MonoBehaviour
{
private Transform _head;
internal void Follow(Transform head)
{
_head = head;
}
private void LateUpdate()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)_head))
{
((Component)this).transform.localPosition = _head.localPosition;
((Component)this).transform.localRotation = _head.localRotation;
}
}
}
[BepInPlugin("Azumatt.SeaLegs", "SeaLegs", "1.0.0")]
public class SeaLegsPlugin : BaseUnityPlugin
{
public enum Toggle
{
On = 1,
Off = 0
}
internal const string ModName = "SeaLegs";
internal const string ModVersion = "1.0.0";
internal const string Author = "Azumatt";
private const string ModGUID = "Azumatt.SeaLegs";
private static string ConfigFileName = "Azumatt.SeaLegs.cfg";
private static string ConfigFileFullPath;
private readonly Harmony _harmony = new Harmony("Azumatt.SeaLegs");
public static readonly ManualLogSource SeaLegsLogger;
internal static ConfigEntry<Toggle> ModEnabled;
internal static ConfigEntry<string> BodyOffsetText;
internal static ConfigEntry<string> ComponentAllowList;
private static string _offsetRaw;
private static Vector3 _offset;
internal static bool IsEnabled
{
get
{
ConfigEntry<Toggle> modEnabled = ModEnabled;
if (modEnabled != null)
{
return modEnabled.Value == Toggle.On;
}
return false;
}
}
internal static Vector3 BodyOffset
{
get
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: 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)
string value = BodyOffsetText.Value;
if (value == _offsetRaw)
{
return _offset;
}
_offsetRaw = value;
_offset = ParseVector(value);
return _offset;
}
}
public void Awake()
{
bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
ModEnabled = config("1 - General", "Enabled", Toggle.On, "Turn the whole mod off without unloading it. Takes effect next time you load into a world.");
BodyOffsetText = config("2 - Body", "Body Offset", "0, 0, -0.2", "x, y, z nudge for the whole body, in body space, metres. Positive z is the way you are facing. The default sits it back far enough that you are not standing in your own collar. Big values not recommended.");
ComponentAllowList = config("3 - Advanced", "Components To Enable", "OtherPlayer,PlayerBody,PlayerLegs,PlayerArms,IK", "Comma separated. These are the components the game switches off on your own player. Anything not in this list stays off.");
Assembly executingAssembly = Assembly.GetExecutingAssembly();
_harmony.PatchAll(executingAssembly);
SetupWatcher();
if (saveOnConfigSet)
{
((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
((BaseUnityPlugin)this).Config.Save();
}
}
private void OnDestroy()
{
((BaseUnityPlugin)this).Config.Save();
}
private void SetupWatcher()
{
FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
fileSystemWatcher.Changed += ReadConfigValues;
fileSystemWatcher.Created += ReadConfigValues;
fileSystemWatcher.Renamed += ReadConfigValues;
fileSystemWatcher.IncludeSubdirectories = true;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
}
private void ReadConfigValues(object sender, FileSystemEventArgs e)
{
if (!File.Exists(ConfigFileFullPath))
{
return;
}
try
{
((BaseUnityPlugin)this).Config.Reload();
}
catch
{
SeaLegsLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
SeaLegsLogger.LogError((object)"Please check your config entries for spelling and format!");
}
}
internal static bool IsLocal(Player? player)
{
if ((Object)(object)player != (Object)null && (Object)(object)Player.LocalPlayer != (Object)null)
{
return (Object)(object)player == (Object)(object)Player.LocalPlayer;
}
return false;
}
private static Vector3 ParseVector(string raw)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
string[] array = raw.Split(new char[1] { ',' });
Vector3 zero = Vector3.zero;
for (int i = 0; i < 3 && i < array.Length; i++)
{
if (float.TryParse(array[i].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
((Vector3)(ref zero))[i] = result;
}
}
return zero;
}
private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description)
{
return ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
}
private ConfigEntry<T> config<T>(string group, string name, T value, string description)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
}
static SeaLegsPlugin()
{
string configPath = Paths.ConfigPath;
char directorySeparatorChar = Path.DirectorySeparatorChar;
ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
SeaLegsLogger = Logger.CreateLogSource("SeaLegs");
ModEnabled = null;
BodyOffsetText = null;
ComponentAllowList = null;
_offsetRaw = null;
}
}
public static class ToggleExtensions
{
[SpecialName]
public sealed class <G>$3B6D679A65CD5647F9CC4965B58E8041
{
[SpecialName]
public static class <M>$48F04745A371B4424895B07F25A43FD8
{
}
[ExtensionMarker("<M>$48F04745A371B4424895B07F25A43FD8")]
public bool IsOn()
{
throw null;
}
[ExtensionMarker("<M>$48F04745A371B4424895B07F25A43FD8")]
public bool IsOff()
{
throw null;
}
}
public static bool IsOn(this SeaLegsPlugin.Toggle toggle)
{
return toggle == SeaLegsPlugin.Toggle.On;
}
public static bool IsOff(this SeaLegsPlugin.Toggle toggle)
{
return toggle == SeaLegsPlugin.Toggle.Off;
}
}
internal static class LocalBody
{
internal static bool Active { get; private set; }
internal static void Build(Player player, List<GameObject> bodyObjects)
{
try
{
foreach (GameObject bodyObject in bodyObjects)
{
if (Object.op_Implicit((Object)(object)bodyObject))
{
bodyObject.SetActive(true);
}
}
EnableAllowedComponents(player);
player.Skin.InitializeOther();
player.Body.ToggleOldModel(player._isBean.Value);
OtherPlayer other = player.Other;
if (Object.op_Implicit((Object)(object)other._col))
{
((Collider)other._col).enabled = false;
}
ApplyHead(player);
if (Object.op_Implicit((Object)(object)player.Body._nameTextCanvasHolder))
{
((Component)player.Body._nameTextCanvasHolder).gameObject.SetActive(false);
}
if (Object.op_Implicit((Object)(object)other._otherPlayerCanvasHolder))
{
((Component)other._otherPlayerCanvasHolder).gameObject.SetActive(false);
}
LocalBodyDriver localBodyDriver = ((Component)player).gameObject.GetComponent<LocalBodyDriver>();
if (!Object.op_Implicit((Object)(object)localBodyDriver))
{
localBodyDriver = ((Component)player).gameObject.AddComponent<LocalBodyDriver>();
}
localBodyDriver.Init(player);
Active = true;
SeaLegsPlugin.SeaLegsLogger.LogInfo((object)$"Body restored, {bodyObjects.Count} object(s) kept alive");
}
catch (Exception arg)
{
Active = false;
SeaLegsPlugin.SeaLegsLogger.LogError((object)$"Failed to restore the local body: {arg}");
}
}
internal static void Clear()
{
Active = false;
}
private static void ApplyHead(Player player)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
Transform head = player.Body.Head;
if (Object.op_Implicit((Object)(object)head))
{
BuildShadowHead(player, head);
head.localScale = Vector3.zero;
}
}
private static void BuildShadowHead(Player player, Transform head)
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: 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)
Transform val = (Object.op_Implicit((Object)(object)player.Other._transform) ? player.Other._transform : head.root);
Transform[] componentsInChildren = ((Component)head).GetComponentsInChildren<Transform>(true);
Transform transform = Object.Instantiate<GameObject>(((Component)head).gameObject, head.parent).transform;
((Object)transform).name = "SeaLegsShadowHead";
transform.localPosition = head.localPosition;
transform.localRotation = head.localRotation;
transform.localScale = Vector3.one;
Transform[] componentsInChildren2 = ((Component)transform).GetComponentsInChildren<Transform>(true);
if (componentsInChildren2.Length != componentsInChildren.Length)
{
Object.Destroy((Object)(object)((Component)transform).gameObject);
SeaLegsPlugin.SeaLegsLogger.LogWarning((object)$"Shadow head came out with {componentsInChildren2.Length} bones against the real {componentsInChildren.Length}. Skipping it.");
return;
}
Dictionary<Transform, Transform> dictionary = new Dictionary<Transform, Transform>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
dictionary[componentsInChildren[i]] = componentsInChildren2[i];
}
Renderer[] componentsInChildren3 = ((Component)transform).GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < componentsInChildren3.Length; j++)
{
componentsInChildren3[j].shadowCastingMode = (ShadowCastingMode)3;
}
int num = 0;
SkinnedMeshRenderer[] componentsInChildren4 = ((Component)val).GetComponentsInChildren<SkinnedMeshRenderer>(true);
foreach (SkinnedMeshRenderer val2 in componentsInChildren4)
{
if (!Object.op_Implicit((Object)(object)val2.sharedMesh) || val2.bones == null || !RidesHead(val2.bones, dictionary))
{
continue;
}
SkinnedMeshRenderer component = Object.Instantiate<GameObject>(((Component)val2).gameObject, ((Component)val2).transform.parent).GetComponent<SkinnedMeshRenderer>();
if (!Object.op_Implicit((Object)(object)component))
{
continue;
}
((Object)component).name = ((Object)val2).name + " (SeaLegs shadow)";
Transform[] bones = component.bones;
for (int k = 0; k < bones.Length; k++)
{
if (Object.op_Implicit((Object)(object)bones[k]) && dictionary.TryGetValue(bones[k], out var value))
{
bones[k] = value;
}
}
component.bones = bones;
if (Object.op_Implicit((Object)(object)component.rootBone) && dictionary.TryGetValue(component.rootBone, out var value2))
{
component.rootBone = value2;
}
((Renderer)component).shadowCastingMode = (ShadowCastingMode)3;
num++;
}
((Component)transform).gameObject.AddComponent<ShadowHeadFollow>().Follow(head);
SeaLegsPlugin.SeaLegsLogger.LogInfo((object)$"Shadow head built from {num} mesh(es)");
}
private static bool RidesHead(Transform[] bones, Dictionary<Transform, Transform> map)
{
foreach (Transform val in bones)
{
if (Object.op_Implicit((Object)(object)val) && map.ContainsKey(val))
{
return true;
}
}
return false;
}
private static void EnableAllowedComponents(Player player)
{
string[] array = SeaLegsPlugin.ComponentAllowList.Value.Split(new char[1] { ',' });
for (int i = 0; i < array.Length; i++)
{
array[i] = array[i].Trim();
}
MonoBehaviour[] disableWhenLocal = player._disableWhenLocal;
foreach (MonoBehaviour val in disableWhenLocal)
{
if (!Object.op_Implicit((Object)(object)val))
{
continue;
}
string name = ((object)val).GetType().Name;
string[] array2 = array;
foreach (string text in array2)
{
if (text.Length != 0 && string.Equals(text, name, StringComparison.OrdinalIgnoreCase))
{
((Behaviour)val).enabled = true;
break;
}
}
}
}
}
[HarmonyPatch(typeof(Player), "InitializePlayer")]
internal static class SaveBodyFromTheDestroyLoop
{
internal static List<GameObject>? Stashed { get; private set; }
private static void Prefix(Player __instance)
{
Stashed = null;
if (SeaLegsPlugin.IsEnabled && ((NetworkBehaviour)__instance).Owner.IsLocalClient)
{
Stashed = __instance._otherObjects;
__instance._otherObjects = new List<GameObject>();
}
}
private static void Postfix(Player __instance)
{
if (Stashed != null)
{
List<GameObject> stashed = Stashed;
Stashed = null;
__instance._otherObjects = stashed;
LocalBody.Build(__instance, stashed);
}
}
}
[HarmonyPatch(typeof(Player), "OnStopClient")]
internal static class ForgetBodyOnDisconnect
{
private static void Postfix(Player __instance)
{
if (SeaLegsPlugin.IsLocal(__instance))
{
LocalBody.Clear();
}
}
}
[HarmonyPatch(typeof(PlayerLegs), "AnimateStep")]
internal static class FlagTheBodysFootstep
{
internal static bool Stepping;
private static void Prefix(PlayerLegs __instance)
{
Stepping = SeaLegsPlugin.IsLocal(__instance._player);
}
private static void Postfix()
{
Stepping = false;
}
}
[HarmonyPatch(typeof(AudioManager), "PlayRandomPlayerClip")]
internal static class DropTheDoubledFootstep
{
private static bool Prefix(Player player)
{
if (FlagTheBodysFootstep.Stepping)
{
return !SeaLegsPlugin.IsLocal(player);
}
return true;
}
}
[HarmonyPatch(typeof(OtherPlayer), "WaterCheck")]
internal static class DropTheDoubledSplash
{
private static bool Prefix(OtherPlayer __instance)
{
return !SeaLegsPlugin.IsLocal(__instance._player);
}
}
}
