using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Lib;
using CSync.Util;
using GameNetcodeStuff;
using HarmonyLib;
using LC_API.ServerAPI;
using Microsoft.CodeAnalysis;
using MovementCompanyEnhanced.Component;
using MovementCompanyEnhanced.Core;
using MovementCompanyEnhanced.Patches;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("MovementCompanyEnhanced")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("General purpose movement mod, fully configurable and allows bhopping.")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0+182845fbaf341a8641eec816c4ac5da02174d425")]
[assembly: AssemblyProduct("MovementCompanyEnhanced")]
[assembly: AssemblyTitle("MovementCompanyEnhanced")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.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]
internal sealed class IsUnmanagedAttribute : Attribute
{
}
[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 MovementCompanyEnhanced
{
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "MovementCompanyEnhanced";
public const string PLUGIN_NAME = "MovementCompanyEnhanced";
public const string PLUGIN_VERSION = "1.2.0";
}
}
namespace MovementCompanyEnhanced.Patches
{
[HarmonyPatch(typeof(GameNetworkManager))]
internal class NetworkManagerPatch
{
[HarmonyPostfix]
[HarmonyPatch("StartDisconnect")]
public static void PlayerLeave()
{
if (SyncedInstance<Config>.Default.SYNC_TO_CLIENTS.Value)
{
SyncedInstance<Config>.RevertSync();
}
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerControllerPatch
{
[CompilerGenerated]
private static class <>O
{
public static HandleNamedMessageDelegate <0>__OnRequestSync;
public static HandleNamedMessageDelegate <1>__OnReceiveSync;
public static Action<CallbackContext> <2>__CrouchCanceled;
}
internal static CustomMovement movementScript;
private static bool removeFirstDelay => SyncedInstance<Config>.Instance.REMOVE_FIRST_JUMP_DELAY.Value;
private static bool removeSecondDelay => SyncedInstance<Config>.Instance.REMOVE_SECOND_JUMP_DELAY.Value;
private static InputActionAsset Actions => IngamePlayerSettings.Instance.playerInput.actions;
[HarmonyPostfix]
[HarmonyPatch("ConnectClientToPlayerObject")]
public static void InitializeLocalPlayer()
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//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_002c: Expected O, but got Unknown
if (SyncedInstance<Config>.IsHost)
{
CustomMessagingManager messageManager = SyncedInstance<Config>.MessageManager;
object obj = <>O.<0>__OnRequestSync;
if (obj == null)
{
HandleNamedMessageDelegate val = Config.OnRequestSync;
<>O.<0>__OnRequestSync = val;
obj = (object)val;
}
messageManager.RegisterNamedMessageHandler("MCE_OnRequestConfigSync", (HandleNamedMessageDelegate)obj);
SyncedInstance<Config>.Synced = true;
return;
}
SyncedInstance<Config>.Synced = false;
CustomMessagingManager messageManager2 = SyncedInstance<Config>.MessageManager;
object obj2 = <>O.<1>__OnReceiveSync;
if (obj2 == null)
{
HandleNamedMessageDelegate val2 = Config.OnReceiveSync;
<>O.<1>__OnReceiveSync = val2;
obj2 = (object)val2;
}
messageManager2.RegisterNamedMessageHandler("MCE_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj2);
Config.RequestSync();
}
[HarmonyPostfix]
[HarmonyPatch("SpawnPlayerAnimation")]
public static void GiveMovementScript(PlayerControllerB __instance)
{
if (Object.op_Implicit((Object)(object)__instance) && !((Object)(object)((Component)__instance).GetComponentInChildren<CustomMovement>() != (Object)null) && ((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
{
movementScript = ((Component)__instance).gameObject.AddComponent<CustomMovement>();
movementScript.player = __instance;
Plugin.Logger.LogInfo((object)"Client player was given the movement script.");
}
}
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public static IEnumerable<CodeInstruction> RemoveJumpDelay(IEnumerable<CodeInstruction> instructions)
{
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
List<CodeInstruction> list = instructions.ToList();
if (!removeFirstDelay && !removeSecondDelay)
{
return list;
}
int num = 0;
for (int i = 0; i < list.Count; i++)
{
CodeInstruction val = list[i];
if (!(val.opcode != OpCodes.Newobj) && (val.operand as ConstructorInfo)?.DeclaringType == typeof(WaitForSeconds) && (num != 0 || removeFirstDelay) && (num != 1 || removeSecondDelay))
{
list[i] = new CodeInstruction(OpCodes.Ldnull, (object)null);
list.RemoveAt(i - 1);
i--;
num++;
}
}
return list;
}
[HarmonyPrefix]
[HarmonyPatch("DamagePlayer")]
public static bool OverrideFallDamage(ref int damageNumber, ref bool fallDamage)
{
if (SyncedInstance<Config>.Default.FALL_DAMAGE_ENABLED.Value)
{
damageNumber = Mathf.Clamp(Mathf.RoundToInt(SyncedInstance<Config>.Instance.FALL_DAMAGE.Value), 0, 100);
return true;
}
return !fallDamage;
}
[HarmonyPrefix]
[HarmonyPatch("Crouch_performed")]
public static bool OnCrouch()
{
if (SyncedInstance<Config>.Default.HOLD_TO_CROUCH.Value)
{
movementScript.player.Crouch(true);
return false;
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch("OnEnable")]
public static void CrouchHold()
{
if (SyncedInstance<Config>.Default.HOLD_TO_CROUCH.Value)
{
RegisterActionCancel(Actions.FindAction("Crouch", true), CrouchCanceled);
}
}
public static void RegisterActionCancel(InputAction action, Action<CallbackContext> callback, bool unregister = false)
{
if (unregister)
{
action.canceled -= callback;
}
else
{
action.canceled += callback;
}
}
private static void CrouchCanceled(CallbackContext _)
{
movementScript.player.Crouch(false);
}
}
}
namespace MovementCompanyEnhanced.Core
{
[BepInPlugin("MovementCompany-Enhanced", "MovementCompany-Enhanced", "1.2.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
private Harmony patcher;
internal static ManualLogSource Logger { get; private set; }
public static Config Config { get; private set; }
private void Awake()
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
Config = new Config(((BaseUnityPlugin)this).Config);
if (!PluginEnabled(logIfDisabled: true))
{
return;
}
Config.InitBindings();
try
{
patcher = new Harmony("MovementCompany-Enhanced");
patcher.PatchAll();
Logger.LogInfo((object)"Plugin loaded.");
}
catch (Exception ex)
{
Logger.LogError((object)ex);
}
}
public void OnDestroy()
{
if (PluginEnabled())
{
ModdedServer.SetServerModdedOnly();
}
}
public bool PluginEnabled(bool logIfDisabled = false)
{
bool value = Config.PLUGIN_ENABLED.Value;
if (!value && logIfDisabled)
{
Logger.LogInfo((object)"MovementCompanyEnhanced disabled globally.");
}
return value;
}
}
public struct ConfigCategory
{
public static ConfigCategory GENERAL => new ConfigCategory("0 >> General << 0");
public static ConfigCategory MOVEMENT => new ConfigCategory("1 >> Movement << 1");
public static ConfigCategory STAMINA => new ConfigCategory("2 >> Stamina << 2");
public static ConfigCategory BHOP => new ConfigCategory("3 >> Bhopping << 3");
public static ConfigCategory MISC => new ConfigCategory("4 >> Miscellaneous << 4");
public string Value { get; private set; }
private ConfigCategory(string value)
{
Value = value;
}
}
[DataContract]
public class Config : SyncedInstance<Config>
{
[NonSerialized]
private readonly ConfigFile configFile;
public ConfigEntry<bool> PLUGIN_ENABLED { get; private set; }
public ConfigEntry<bool> DISPLAY_DEBUG_INFO { get; private set; }
[DataMember]
public SyncedEntry<bool> SYNC_TO_CLIENTS { get; private set; }
[DataMember]
public SyncedEntry<bool> HOLD_TO_CROUCH { get; private set; }
[DataMember]
public SyncedEntry<bool> REMOVE_FIRST_JUMP_DELAY { get; private set; }
[DataMember]
public SyncedEntry<bool> REMOVE_SECOND_JUMP_DELAY { get; private set; }
[DataMember]
public SyncedEntry<float> MOVEMENT_SPEED { get; private set; }
[DataMember]
public SyncedEntry<float> CLIMB_SPEED { get; private set; }
[DataMember]
public SyncedEntry<float> SINK_SPEED_MULTIPLIER { get; private set; }
[DataMember]
public SyncedEntry<bool> FALL_DAMAGE_ENABLED { get; private set; }
[DataMember]
public SyncedEntry<float> FALL_DAMAGE { get; private set; }
[DataMember]
public SyncedEntry<bool> INFINITE_STAMINA { get; private set; }
[DataMember]
public SyncedEntry<float> MAX_STAMINA { get; private set; }
[DataMember]
public SyncedEntry<bool> BHOP_IN_FACTORY { get; private set; }
[DataMember]
public SyncedEntry<bool> BHOP_IN_SHIP { get; private set; }
[DataMember]
public SyncedEntry<float> MAX_JUMP_DURATION { get; private set; }
[DataMember]
public SyncedEntry<float> ROTATION_THRESHOLD { get; private set; }
[DataMember]
public SyncedEntry<float> JUMP_TIME_MULTIPLIER { get; private set; }
[DataMember]
public SyncedEntry<float> MAX_AIR_VELOCITY { get; private set; }
[DataMember]
public SyncedEntry<float> FORWARD_VELOCITY_DAMPER { get; private set; }
[DataMember]
public SyncedEntry<float> AIR_VELOCITY_MULTIPLIER { get; private set; }
[DataMember]
public SyncedEntry<float> GROUND_VELOCITY_MULTIPLIER { get; private set; }
public Config(ConfigFile cfg)
{
base.InitInstance(this);
configFile = cfg;
PLUGIN_ENABLED = NewEntry(ConfigCategory.GENERAL, "bEnabled", defaultVal: true, "Enable or disable the plugin globally.");
}
private ConfigEntry<V> NewEntry<V>(ConfigCategory category, string key, V defaultVal, string desc)
{
return configFile.Bind<V>(category.Value, key, defaultVal, desc);
}
private SyncedEntry<V> NewSyncedEntry<V>(ConfigCategory category, string key, V defaultVal, string desc) where V : unmanaged
{
return Extensions.BindSyncedEntry<V>(configFile, category.Value, key, defaultVal, desc);
}
public void InitBindings()
{
DISPLAY_DEBUG_INFO = NewEntry(ConfigCategory.GENERAL, "bDisplayDebugInfo", defaultVal: false, "Whether to display coordinates, velocity and other debug info.");
SYNC_TO_CLIENTS = NewSyncedEntry(ConfigCategory.GENERAL, "bSyncToClients", defaultVal: true, "As the host, should clients be forced to use our config values?\nSetting this to `false` will allow clients to use their own config.");
MOVEMENT_SPEED = NewSyncedEntry(ConfigCategory.MOVEMENT, "fMovementSpeed", 4.1f, "The base speed at which the player moves. This is NOT a multiplier.");
CLIMB_SPEED = NewSyncedEntry(ConfigCategory.MOVEMENT, "fClimbSpeed", 3.9f, "The base speed at which the player climbs. This is NOT a multiplier.");
SINK_SPEED_MULTIPLIER = NewSyncedEntry(ConfigCategory.MOVEMENT, "fSinkSpeedMultiplier", 0.16f, "Value to multiply the sinking speed by when in quicksand.\nDon't want to sink as fast? Decrease this value.");
HOLD_TO_CROUCH = NewSyncedEntry(ConfigCategory.MOVEMENT, "bHoldToCrouch", defaultVal: true, "Whether the player should hold to crouch instead of a toggle.\nNOTE: This setting is client-side and cannot be forced by the host.");
REMOVE_FIRST_JUMP_DELAY = NewSyncedEntry(ConfigCategory.MOVEMENT, "bRemoveFirstJumpDelay", defaultVal: true, "Removes the immediate jump delay of 150ms after jumping.");
REMOVE_SECOND_JUMP_DELAY = NewSyncedEntry(ConfigCategory.MOVEMENT, "bRemoveSecondJumpDelay", defaultVal: true, "Removes the jump delay of 100ms before jumping can end.");
FALL_DAMAGE_ENABLED = NewSyncedEntry(ConfigCategory.MOVEMENT, "bFallDamageEnabled", defaultVal: true, "Whether you take fall damage. 4Head");
FALL_DAMAGE = NewSyncedEntry(ConfigCategory.MOVEMENT, "fFallDamage", 16.5f, "How much base HP the player loses from every fall. Clamped between 0-100.");
INFINITE_STAMINA = NewSyncedEntry(ConfigCategory.STAMINA, "bInfiniteStamina", defaultVal: true, "Whether the player has infinite stamina (essential for bhopping).\nOnly applies wherever bhopping is allowed.\nNOTE: THIS WILL BE REPLACED IN FUTURE.");
MAX_STAMINA = NewSyncedEntry(ConfigCategory.STAMINA, "fMaxStamina", 200f, "The amount at which the sprint meter (aka stamina) is considered full.\nClamped between 0 and 1 in the base game.");
BHOP_IN_FACTORY = NewSyncedEntry(ConfigCategory.BHOP, "bBhopInFactory", defaultVal: false, "Whether bhopping (not general movement) is allowed inside the factory.");
BHOP_IN_SHIP = NewSyncedEntry(ConfigCategory.BHOP, "bBhopInFactory", defaultVal: false, "Whether bhopping (not general movement) is allowed inside the ship.");
MAX_JUMP_DURATION = NewSyncedEntry(ConfigCategory.BHOP, "fMaxJumpDuration", 0.0025f, "The maximum amount of time a jump can last for.");
ROTATION_THRESHOLD = NewSyncedEntry(ConfigCategory.BHOP, "fRotationThreshold", 0.0115f, "The magnitude at which to begin applying velocity. Higher = more rotation required.");
JUMP_TIME_MULTIPLIER = NewSyncedEntry(ConfigCategory.BHOP, "fJumpTimeMultiplier", 29f, "The value to multiply 'jump time' by, affecting how quickly you hit MaxJumpDuration.\nLower values will cause the player to feel more weightless.");
MAX_AIR_VELOCITY = NewSyncedEntry(ConfigCategory.BHOP, "fMaxAirVelocity", 60f, "The value at which velocity will stop being applied when airborne.");
FORWARD_VELOCITY_DAMPER = NewSyncedEntry(ConfigCategory.BHOP, "fForwardVelocityDamper", 1.65f, "After jumping, a forward velocity is applied - which is first dampened by this value.\nNote: Increasing this value too much may hinder bhopping.");
AIR_VELOCITY_MULTIPLIER = NewSyncedEntry(ConfigCategory.BHOP, "fAirVelocityMultiplier", 0.0046f, "The value to multiply the player's velocity by when airborne.\nNote: Do not let the small value fool you, anything above the default is veryy fast!");
GROUND_VELOCITY_MULTIPLIER = NewSyncedEntry(ConfigCategory.BHOP, "fGroundVelocityMultiplier", 1.9f, "The value determining how quickly velocity decreases when not airborne.\nEssentially, this affects how much the player is slowed down when hitting the ground.");
}
internal static void RequestSync()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<Config>.IsClient)
{
return;
}
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(ByteSerializer<Config>.IntSize, (Allocator)2, -1);
try
{
Extensions.SendMessage(val, "MCE_OnRequestConfigSync", 0uL);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
internal static void OnRequestSync(ulong clientId, FastBufferReader _)
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<Config>.IsHost)
{
return;
}
Plugin.Logger.LogDebug((object)$"Config sync request received from client: {clientId}");
byte[] array = ByteSerializer<Config>.SerializeToBytes(SyncedInstance<Config>.Instance);
int num = array.Length;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(num + ByteSerializer<Config>.IntSize, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
Extensions.SendMessage(val, "MCE_OnReceiveConfigSync", clientId);
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
internal static void OnReceiveSync(ulong _, FastBufferReader reader)
{
//IL_0024: 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)
if (!((FastBufferReader)(ref reader)).TryBeginRead(ByteSerializer<Config>.IntSize))
{
Plugin.Logger.LogError((object)"Config sync error: Could not begin reading buffer.");
return;
}
int num = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
{
Plugin.Logger.LogError((object)"Config sync error: Host could not sync.");
return;
}
byte[] array = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref array, num, 0);
try
{
SyncedInstance<Config>.SyncInstance(array);
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"Error syncing config instance!\n{arg}");
}
PlayerControllerPatch.movementScript.ApplyConfigSpeeds();
}
}
internal static class Metadata
{
public const string GUID = "MovementCompany-Enhanced";
public const string NAME = "MovementCompany-Enhanced";
public const string VERSION = "1.2.0";
}
}
namespace MovementCompanyEnhanced.Component
{
internal class CustomMovement : MonoBehaviour
{
private float jumpTime;
private bool inAir;
private Vector3 wantedVelToAdd;
private Vector3 velToAdd;
private Vector3 previousForward;
public PlayerControllerB player { get; internal set; }
internal Config cfg => SyncedInstance<Config>.Instance;
private void OnGUI()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
if (SyncedInstance<Config>.Default.DISPLAY_DEBUG_INFO.Value && !((Object)(object)player.thisController == (Object)null))
{
Vector3 position = ((Component)player.thisController).transform.position;
GUI.Label(new Rect(10f, 10f, 500f, 500f), Vec3ToString(position));
GUI.Label(new Rect(10f, 40f, 500f, 500f), "Current Velocity: " + Math.Round(CurrentVelocity(), 3));
GUI.Label(new Rect(10f, 60f, 500f, 500f), "Wanted Velocity: " + Math.Round(((Vector3)(ref wantedVelToAdd)).magnitude, 3));
GUI.Label(new Rect(10f, 90f, 500f, 500f), "Jump Time: " + jumpTime);
GUI.Label(new Rect(10f, 110f, 500f, 500f), "Airborne: " + inAir);
GUI.Label(new Rect(10f, 130f, 500f, 500f), "Airborne (Actual): " + Airborne());
}
}
private void Start()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
if (SyncedInstance<Config>.IsHost)
{
ApplyConfigSpeeds(host: true);
}
velToAdd = new Vector3(0.0002f, 0.0002f, 0.0002f);
MovePlayer(0f, -0.5f, 0f);
}
private void Update()
{
if (Object.op_Implicit((Object)(object)player) && (!player.isInHangarShipRoom || cfg.BHOP_IN_SHIP.Value) && (!player.isInsideFactory || cfg.BHOP_IN_FACTORY.Value))
{
Animator playerBodyAnimator = player.playerBodyAnimator;
bool jumping = playerBodyAnimator != null && playerBodyAnimator.GetBool("Jumping");
if (cfg.INFINITE_STAMINA.Value)
{
SetStamina(cfg.MAX_STAMINA.Value);
}
UpdateJumpTime(jumping);
if (!Airborne())
{
LerpToGround();
}
else if (!ReachedMaxVelocity())
{
ApplyBhop();
}
}
}
internal void ApplyConfigSpeeds(bool host = false)
{
string arg = (host ? "Host" : "Client");
Plugin.Logger.LogDebug((object)$"{arg} - move speed set to: {cfg?.MOVEMENT_SPEED?.Value}");
player.movementSpeed = ValNonNegative(cfg.MOVEMENT_SPEED.Value);
player.climbSpeed = ValNonNegative(cfg.CLIMB_SPEED.Value);
player.sinkingSpeedMultiplier = ValNonNegative(cfg.SINK_SPEED_MULTIPLIER.Value);
}
private void UpdateJumpTime(bool jumping)
{
if (jumping && jumpTime < cfg.MAX_JUMP_DURATION.Value)
{
player.fallValue = player.jumpForce;
jumpTime += Time.deltaTime * cfg.JUMP_TIME_MULTIPLIER.Value / 100f;
}
}
private void LerpToGround()
{
//IL_0019: 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)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
float num = Time.deltaTime * cfg.GROUND_VELOCITY_MULTIPLIER.Value;
wantedVelToAdd = Vector3.Lerp(wantedVelToAdd, Vector3.zero, num);
inAir = false;
jumpTime = 0f;
}
private void ApplyBhop()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
if (!inAir)
{
inAir = true;
AddJumpVelocity(cfg.AIR_VELOCITY_MULTIPLIER.Value);
}
wantedVelToAdd.y = 0f;
MovePlayer(CurrentForward() * (((Vector3)(ref wantedVelToAdd)).magnitude / cfg.FORWARD_VELOCITY_DAMPER.Value));
AddRotationVelocity(cfg.ROTATION_THRESHOLD.Value);
}
private void AddJumpVelocity(float multiplier)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: 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_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
Vector3 velocity = player.thisController.velocity;
velocity.y = 0f;
if (((Vector3)(ref wantedVelToAdd)).magnitude < 0.2f)
{
wantedVelToAdd += velocity * multiplier;
}
}
private void AddRotationVelocity(float threshold)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: 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)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = CurrentForward() - previousForward;
if (((Vector3)(ref val)).magnitude > threshold)
{
wantedVelToAdd += velToAdd;
}
previousForward = CurrentForward();
}
private void MovePlayer(Vector3 motion)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
player.thisController.Move(motion);
}
private void MovePlayer(float x, float y, float z)
{
//IL_000e: 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)
player.thisController.Move(new Vector3(x, y, z));
}
public bool Airborne()
{
if (!player.thisController.isGrounded)
{
return !player.isClimbingLadder;
}
return false;
}
public Vector3 CurrentForward()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
return ((Component)player).transform.forward;
}
public float CurrentVelocity()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
Vector3 velocity = player.thisController.velocity;
return ((Vector3)(ref velocity)).magnitude;
}
public bool ReachedMaxVelocity()
{
return CurrentVelocity() >= cfg.MAX_AIR_VELOCITY.Value;
}
private void SetStamina(float val)
{
player.sprintMeter = ValNonNegative(val);
}
private float ValNonNegative(float newVal)
{
if (newVal <= 0f)
{
newVal = 0f;
}
return newVal;
}
public string Vec3ToString(Vector3 vec)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: 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)
float num = (float)Math.Round(vec.x, 1);
float num2 = (float)Math.Round(vec.y, 1);
float num3 = (float)Math.Round(vec.z, 1);
return $"X: {num}, Y: {num2}, Z: {num3}";
}
}
}
