using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalGym.Scripts;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalGym")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LethalGym")]
[assembly: AssemblyTitle("LethalGym")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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]
[Microsoft.CodeAnalysis.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;
}
}
}
public class Equipment : NetworkBehaviour
{
[CompilerGenerated]
private sealed class <RefreshBenchAnimatorAfterExit>d__37 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public PlayerControllerB player;
public Equipment <>4__this;
private AnimatorOverrideController <controller>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RefreshBenchAnimatorAfterExit>d__37(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<controller>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 2;
return true;
case 2:
{
<>1__state = -1;
if ((Object)(object)player == (Object)null || (Object)(object)player.playerBodyAnimator == (Object)null)
{
return false;
}
ref AnimatorOverrideController reference = ref <controller>5__1;
RuntimeAnimatorController runtimeAnimatorController = player.playerBodyAnimator.runtimeAnimatorController;
reference = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
if ((Object)(object)<controller>5__1 != (Object)null)
{
resetAnimations(<controller>5__1);
}
player.playerBodyAnimator.Update(0f);
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <playRep>d__28 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Equipment <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <playRep>d__28(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if ((Object)(object)<>4__this.playerController != (Object)null && (Object)(object)<>4__this.playerController.playerBodyAnimator != (Object)null)
{
<>4__this.playerController.playerBodyAnimator.Play("SpecialAnimations.TypeOnTerminal2", -1, 0f);
}
if ((Object)(object)<>4__this.animator != (Object)null)
{
<>4__this.animator.Play("Base Layer.EquipmentRepAnimation", -1, 0f);
}
<>4__this.isRepping = true;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>4__this.isRepping = false;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public PlayerActions playerActions;
public InteractTrigger trigger;
public Animator animator;
public TMP_Text nameText;
public TMP_Text repsText;
public GameObject[] weights;
public string EquipmentName;
public int playerStrengthLevel;
public AnimatorOverrideController overrideController;
public AnimationClip equipmentEnter;
public AnimationClip equipmentRep;
public static AnimationClip benchEnter;
public static AnimationClip benchRep;
public static AnimationClip squatEnter;
public static AnimationClip squatRep;
public int reps;
public bool inUse;
public bool isRepping;
public PlayerControllerB playerController;
public PlayerStrengthLevel psl;
public void Awake()
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
//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)
inUse = false;
playerActions = new PlayerActions();
MovementActions movement = playerActions.Movement;
((MovementActions)(ref movement)).Enable();
trigger = ((Component)this).GetComponent<InteractTrigger>();
}
private void OnEnable()
{
//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_002c: 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)
MovementActions movement = playerActions.Movement;
((MovementActions)(ref movement)).Interact.performed += BackOut;
movement = playerActions.Movement;
((MovementActions)(ref movement)).Use.performed += Rep;
}
private void OnDisable()
{
//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_002c: 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)
MovementActions movement = playerActions.Movement;
((MovementActions)(ref movement)).Interact.performed -= BackOut;
movement = playerActions.Movement;
((MovementActions)(ref movement)).Use.performed -= Rep;
}
public void Start()
{
nameText.text = "Enter Bench";
repsText.text = "To Start Count";
if (EquipmentName == "Bench")
{
equipmentEnter = benchEnter;
equipmentRep = benchRep;
}
else if (EquipmentName == "Squat")
{
equipmentEnter = squatEnter;
equipmentRep = squatRep;
}
else
{
Debug.LogError((object)"No Name?");
}
}
public void Update()
{
if ((Object)(object)nameText != (Object)null && (Object)(object)repsText != (Object)null && (Object)(object)psl != (Object)null && (Object)(object)playerController != (Object)null)
{
nameText.text = playerController.playerUsername + "'s";
repsText.text = "Reps:" + psl.currentRepsInLevel;
}
}
public void Rep(CallbackContext context)
{
if (inUse && !isRepping && !((Object)(object)playerController == (Object)null) && playerController.playerClientId == GameNetworkManager.Instance.localPlayerController.playerClientId)
{
RepServerRpc();
}
}
[ServerRpc(RequireOwnership = false)]
public void RepServerRpc()
{
if (!((Object)(object)playerController == (Object)null))
{
((MonoBehaviour)this).StartCoroutine(playRep());
reps++;
PlayerStrengthLevel component = ((Component)playerController).gameObject.GetComponent<PlayerStrengthLevel>();
if ((Object)(object)component != (Object)null)
{
component.addRep(this);
}
RepClientRpc(reps);
}
}
[ClientRpc]
public void RepClientRpc(int serverReps)
{
reps = serverReps;
((MonoBehaviour)this).StartCoroutine(playRep());
}
[IteratorStateMachine(typeof(<playRep>d__28))]
public IEnumerator playRep()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <playRep>d__28(0)
{
<>4__this = this
};
}
public void OnEnter(PlayerControllerB player)
{
Debug.LogWarning((object)"Entered");
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
OnEnterServerRpc(localPlayerController.playerClientId);
}
[ServerRpc(RequireOwnership = false)]
public void OnEnterServerRpc(ulong playerInBenchID)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
inUse = true;
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (val.playerClientId == playerInBenchID)
{
playerController = val;
RuntimeAnimatorController runtimeAnimatorController = val.playerBodyAnimator.runtimeAnimatorController;
overrideController = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
if ((Object)(object)overrideController == (Object)null)
{
overrideController = new AnimatorOverrideController(runtimeAnimatorController);
val.playerBodyAnimator.runtimeAnimatorController = (RuntimeAnimatorController)(object)overrideController;
}
psl = ((Component)val).GetComponent<PlayerStrengthLevel>();
playerStrengthLevel = ((Component)val).GetComponent<PlayerStrengthLevel>().playerStrength;
break;
}
}
if ((Object)(object)equipmentEnter == (Object)null)
{
Debug.LogError((object)"equipmentEnter is null");
}
else
{
Debug.LogError((object)((Object)equipmentEnter).name.ToString());
}
if ((Object)(object)equipmentRep == (Object)null)
{
Debug.LogError((object)"equipmentRep is null");
}
else
{
Debug.LogError((object)((Object)equipmentRep).name.ToString());
}
if ((Object)(object)overrideController != (Object)null)
{
Debug.LogError((object)((Object)overrideController).name.ToString());
overrideController["TypeOnTerminal"] = equipmentEnter;
overrideController["TypeOnTerminal2"] = equipmentRep;
}
SetWeights(playerStrengthLevel);
Debug.LogError((object)playerStrengthLevel);
animator.ResetTrigger("EquipmentRep");
animator.SetTrigger("EquipmentRep");
reps = 1;
OnEnterClientRpc(playerInBenchID);
}
[ClientRpc]
public void OnEnterClientRpc(ulong playerInBenchID)
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
inUse = true;
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (val.playerClientId == playerInBenchID)
{
playerController = val;
RuntimeAnimatorController runtimeAnimatorController = val.playerBodyAnimator.runtimeAnimatorController;
overrideController = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
if ((Object)(object)overrideController == (Object)null)
{
overrideController = new AnimatorOverrideController(runtimeAnimatorController);
val.playerBodyAnimator.runtimeAnimatorController = (RuntimeAnimatorController)(object)overrideController;
}
psl = ((Component)val).GetComponent<PlayerStrengthLevel>();
if ((Object)(object)psl == (Object)null)
{
Debug.LogWarning((object)"no psl");
}
playerStrengthLevel = ((Component)val).GetComponent<PlayerStrengthLevel>().playerStrength;
break;
}
}
if ((Object)(object)equipmentEnter == (Object)null)
{
Debug.LogError((object)"equipmentEnter is null");
}
else
{
Debug.LogError((object)((Object)equipmentEnter).name.ToString());
}
if ((Object)(object)equipmentRep == (Object)null)
{
Debug.LogError((object)"equipmentRep is null");
}
else
{
Debug.LogError((object)((Object)equipmentRep).name.ToString());
}
if ((Object)(object)overrideController == (Object)null)
{
Debug.LogError((object)"no overridecontroller");
}
else
{
overrideController["TypeOnTerminal"] = equipmentEnter;
overrideController["TypeOnTerminal2"] = equipmentRep;
}
SetWeights(playerStrengthLevel);
Debug.LogError((object)playerStrengthLevel);
animator.ResetTrigger("EquipmentRep");
animator.SetTrigger("EquipmentRep");
reps = 1;
}
public void BackOut(CallbackContext context)
{
if (inUse && !((Object)(object)playerController == (Object)null) && playerController.playerClientId == GameNetworkManager.Instance.localPlayerController.playerClientId)
{
StopSpecialAnimation();
BackOutServerRpc();
}
}
public void StopSpecialAnimation()
{
if ((Object)(object)trigger != (Object)null)
{
trigger.StopSpecialAnimation();
}
}
[ServerRpc(RequireOwnership = false)]
public void BackOutServerRpc()
{
Debug.LogWarning((object)"BACKOUT CONFIRM");
LeaveEquipment();
BackOutClientRpc();
}
[ClientRpc]
public void BackOutClientRpc()
{
Debug.LogWarning((object)"BACKOUT CONFIRM");
LeaveEquipment();
}
public void LeaveEquipment()
{
PlayerControllerB val = playerController;
bool flag = EquipmentName == "Bench";
if ((Object)(object)animator != (Object)null)
{
animator.SetTrigger("StopAnimation");
}
inUse = false;
isRepping = false;
playerController = null;
psl = null;
if (flag && (Object)(object)val != (Object)null)
{
((MonoBehaviour)this).StartCoroutine(RefreshBenchAnimatorAfterExit(val));
}
}
[IteratorStateMachine(typeof(<RefreshBenchAnimatorAfterExit>d__37))]
private IEnumerator RefreshBenchAnimatorAfterExit(PlayerControllerB player)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RefreshBenchAnimatorAfterExit>d__37(0)
{
<>4__this = this,
player = player
};
}
public void SetWeights(int levelNumber)
{
for (int i = 0; i < weights.Length; i++)
{
if (i == 0)
{
weights[i].SetActive(true);
}
else
{
weights[i].SetActive(false);
}
}
if (levelNumber == 1)
{
weights[0].SetActive(true);
}
if (levelNumber >= 2)
{
weights[1].SetActive(true);
}
if (levelNumber >= 3)
{
weights[2].SetActive(true);
}
if (levelNumber >= 4)
{
weights[3].SetActive(true);
}
if (levelNumber >= 5)
{
weights[4].SetActive(true);
}
if (levelNumber >= 6)
{
weights[5].SetActive(true);
}
}
[ServerRpc(RequireOwnership = false)]
public void BeginTerminalServerRPC(ulong playerID)
{
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (val.playerClientId == playerID)
{
RuntimeAnimatorController runtimeAnimatorController = val.playerBodyAnimator.runtimeAnimatorController;
AnimatorOverrideController val2 = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
if ((Object)(object)val2 != (Object)null)
{
resetAnimations(val2);
}
break;
}
}
BeginTerminalClientRPC(playerID);
}
[ClientRpc]
public void BeginTerminalClientRPC(ulong playerID)
{
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (val.playerClientId == playerID)
{
RuntimeAnimatorController runtimeAnimatorController = val.playerBodyAnimator.runtimeAnimatorController;
AnimatorOverrideController val2 = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
if ((Object)(object)val2 != (Object)null)
{
resetAnimations(val2);
}
break;
}
}
}
public static void resetAnimations(AnimatorOverrideController controller)
{
List<KeyValuePair<AnimationClip, AnimationClip>> list = new List<KeyValuePair<AnimationClip, AnimationClip>>(controller.overridesCount);
controller.GetOverrides(list);
for (int i = 0; i < list.Count; i++)
{
list[i] = new KeyValuePair<AnimationClip, AnimationClip>(list[i].Key, null);
}
controller.ApplyOverrides((IList<KeyValuePair<AnimationClip, AnimationClip>>)list);
}
}
public class PlayerStrengthLevel : NetworkBehaviour
{
public int playerStrength = 1;
public int currentRepsInLevel = 0;
public static int repsNeededL1 = 25;
public static int repsNeededL2 = 50;
public static int repsNeededL3 = 75;
public static int repsNeededL4 = 100;
public static int repsNeededL5 = 200;
public bool canGrab;
public bool canDrop;
public static bool strongerBodyStatus;
public float originalCarryWeight;
public PlayerControllerB playerController;
public void Start()
{
originalCarryWeight = 1f;
canGrab = true;
canDrop = true;
}
public void Update()
{
}
public void UpdateConfigs(bool nStrongerBodyStatus)
{
strongerBodyStatus = nStrongerBodyStatus;
}
public void addRep(Equipment bench)
{
currentRepsInLevel++;
Debug.LogWarning((object)currentRepsInLevel.ToString());
if (playerStrength == 1 && currentRepsInLevel >= repsNeededL1)
{
playerStrength++;
currentRepsInLevel = 0;
bench.SetWeights(playerStrength);
Debug.Log((object)(playerStrength + " PlayerUpgraded!"));
}
if (playerStrength == 2 && currentRepsInLevel >= repsNeededL2)
{
playerStrength++;
currentRepsInLevel = 0;
bench.SetWeights(playerStrength);
Debug.Log((object)(playerStrength + " PlayerUpgraded!"));
}
if (playerStrength == 3 && currentRepsInLevel >= repsNeededL3)
{
playerStrength++;
currentRepsInLevel = 0;
bench.SetWeights(playerStrength);
Debug.Log((object)(playerStrength + " PlayerUpgraded!"));
}
if (playerStrength == 4 && currentRepsInLevel >= repsNeededL4)
{
playerStrength++;
currentRepsInLevel = 0;
bench.SetWeights(playerStrength);
Debug.Log((object)(playerStrength + " PlayerUpgraded!"));
}
if (playerStrength == 5 && currentRepsInLevel >= repsNeededL5)
{
bench.repsText.text = "MAXED OUT";
Debug.Log((object)"Bro is maxed out");
}
}
}
namespace LethalGym
{
[BepInPlugin("Dryedcoolbro.LethalGym", "LethalGym", "1.0.0.0")]
public class Plugin : BaseUnityPlugin
{
private const string modGUID = "Dryedcoolbro.LethalGym";
private const string modName = "LethalGym";
private const string modVersion = "1.0.0.0";
private readonly Harmony harmony = new Harmony("Dryedcoolbro.LethalGym");
private static Plugin Instance;
internal static ManualLogSource Logger;
public static AssetBundle assetBundle;
public static AnimationClip pushupAnimation;
public static UnlockablesList unlockablesList;
public static Config Config { get; private set; }
public static bool IsModLoaded(string guid)
{
return Chainloader.PluginInfos.ContainsKey(guid);
}
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
Config = new Config(((BaseUnityPlugin)this).Config);
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
Logger = Logger.CreateLogSource("Dryedcoolbro.LethalGym");
assetBundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "lethalequipment"));
LoadAnimations();
if ((Object)(object)pushupAnimation == (Object)null)
{
Logger.LogError((object)"pushupAnim not exist!");
}
else
{
Logger.LogInfo((object)((Object)pushupAnimation).name);
}
if ((Object)(object)assetBundle == (Object)null)
{
Logger.LogError((object)"Assetbundle not exist!");
}
else
{
Logger.LogInfo((object)((object)assetBundle).ToString());
Logger.LogInfo((object)((Object)assetBundle).name);
}
harmony.PatchAll();
NetworkObjectManager.assetBundle = assetBundle;
unlockablesList = assetBundle.LoadAsset<UnlockablesList>("Assets/MyAssets/Unlockables.asset");
unlockablesList = unlockablesList;
LoadNetworkPrefabs();
RegisterUnlockables();
}
public static void LoadAnimations()
{
Equipment.benchEnter = assetBundle.LoadAsset<AnimationClip>("Assets/MyAssets/Bench/BenchPressStart.anim");
Equipment.benchRep = assetBundle.LoadAsset<AnimationClip>("Assets/MyAssets/Bench/BenchRep.anim");
Equipment.squatEnter = assetBundle.LoadAsset<AnimationClip>("Assets/MyAssets/SquatRack/SquatEnter.anim");
Equipment.squatRep = assetBundle.LoadAsset<AnimationClip>("Assets/MyAssets/SquatRack/SquatRep.anim");
}
public static void LoadNetworkPrefabs()
{
NetworkPrefabs.RegisterNetworkPrefab(unlockablesList.unlockables[0].prefabObject);
NetworkPrefabs.RegisterNetworkPrefab(unlockablesList.unlockables[1].prefabObject);
}
public static void RegisterUnlockables()
{
ConfigApply.unlockablesList = unlockablesList;
Unlockables.RegisterUnlockable(unlockablesList.unlockables[0], (StoreType)1, (TerminalNode)null, (TerminalNode)null, (TerminalNode)null, 60);
Unlockables.RegisterUnlockable(unlockablesList.unlockables[1], (StoreType)1, (TerminalNode)null, (TerminalNode)null, (TerminalNode)null, 60);
}
}
[DataContract]
public class Config : SyncedInstance<Config>
{
[DataMember]
public bool strongerBody { get; private set; }
[DataMember]
public bool overridePrices { get; private set; }
[DataMember]
public int benchPrice { get; private set; }
[DataMember]
public int squatPrice { get; private set; }
public Config(ConfigFile cfg)
{
InitInstance(this);
strongerBody = cfg.Bind<bool>("General", "Stronger Body", false, "More strength levels you have, the faster you can walk while carrying heavy items").Value;
overridePrices = cfg.Bind<bool>("Prices", "Override Prices", false, "If set to true, all prices underneath will be set as the price no matter what.").Value;
benchPrice = cfg.Bind<int>("Prices", "Bench Price", 60, "Default is 60").Value;
squatPrice = cfg.Bind<int>("Prices", "Squat Rack Price", 60, "Default is 60").Value;
}
public static void RequestSync()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<Config>.IsClient)
{
return;
}
FastBufferWriter stream = default(FastBufferWriter);
((FastBufferWriter)(ref stream))..ctor(SyncedInstance<Config>.IntSize, (Allocator)2, -1);
try
{
SyncedInstance<Config>.SendMessage("ModName_OnRequestConfigSync", 0uL, stream);
}
finally
{
((IDisposable)(FastBufferWriter)(ref stream)).Dispose();
}
}
public static void OnRequestSync(ulong clientId, FastBufferReader _)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<Config>.IsHost)
{
return;
}
Plugin.Logger.LogInfo((object)$"Config sync request received from client: {clientId}");
byte[] array = SyncedInstance<Config>.SerializeToBytes(SyncedInstance<Config>.Instance);
int num = array.Length;
FastBufferWriter stream = default(FastBufferWriter);
((FastBufferWriter)(ref stream))..ctor(num + SyncedInstance<Config>.IntSize, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref stream)).WriteValueSafe<int>(ref num, default(ForPrimitives));
((FastBufferWriter)(ref stream)).WriteBytesSafe(array, -1, 0);
SyncedInstance<Config>.SendMessage("ModName_OnReceiveConfigSync", clientId, stream);
}
catch (Exception arg)
{
Plugin.Logger.LogInfo((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
}
finally
{
((IDisposable)(FastBufferWriter)(ref stream)).Dispose();
}
}
public static void OnReceiveSync(ulong _, FastBufferReader reader)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<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[] data = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
SyncedInstance<Config>.SyncInstance(data);
Plugin.Logger.LogInfo((object)"Successfully synced config with host.");
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
public static void InitializeLocalPlayer()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
if (SyncedInstance<Config>.IsHost)
{
SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("ModName_OnRequestConfigSync", new HandleNamedMessageDelegate(OnRequestSync));
SyncedInstance<Config>.Synced = true;
}
else
{
SyncedInstance<Config>.Synced = false;
SyncedInstance<Config>.MessageManager.RegisterNamedMessageHandler("ModName_OnReceiveConfigSync", new HandleNamedMessageDelegate(OnReceiveSync));
RequestSync();
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
public static void PlayerLeave()
{
SyncedInstance<Config>.RevertSync();
}
}
[Serializable]
public class SyncedInstance<T>
{
[NonSerialized]
protected static int IntSize = 4;
[NonSerialized]
private static readonly DataContractSerializer serializer = new DataContractSerializer(typeof(T));
internal static bool Synced;
[NonSerialized]
private static int MAX_BUFFER_SIZE = 1300;
public static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;
public static bool IsClient => NetworkManager.Singleton.IsClient;
public static bool IsHost => NetworkManager.Singleton.IsHost;
internal static T Default { get; private set; }
internal static T Instance { get; private set; }
protected void InitInstance(T instance, int maxSize = 1024)
{
Default = instance;
Instance = instance;
IntSize = 4;
if (maxSize < 1300)
{
MAX_BUFFER_SIZE = maxSize;
}
}
internal static void SyncInstance(byte[] data)
{
Instance = DeserializeFromBytes(data);
Synced = true;
}
internal static void RevertSync()
{
Instance = Default;
Synced = false;
}
public static byte[] SerializeToBytes(T val)
{
using MemoryStream memoryStream = new MemoryStream();
try
{
serializer.WriteObject(memoryStream, val);
return memoryStream.ToArray();
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"Error serializing instance: {arg}");
return null;
}
}
public static T DeserializeFromBytes(byte[] data)
{
using MemoryStream stream = new MemoryStream(data);
try
{
return (T)serializer.ReadObject(stream);
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"Error deserializing instance: {arg}");
return default(T);
}
}
internal static void SendMessage(string label, ulong clientId, FastBufferWriter stream)
{
//IL_0017: 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_0052: Unknown result type (might be due to invalid IL or missing references)
bool flag = ((FastBufferWriter)(ref stream)).Capacity > MAX_BUFFER_SIZE;
NetworkDelivery val = (NetworkDelivery)(flag ? 4 : 2);
if (flag)
{
Plugin.Logger.LogDebug((object)($"Size of stream ({((FastBufferWriter)(ref stream)).Capacity}) was past the max buffer size.\n" + "Config instance will be sent in fragments to avoid overflowing the buffer."));
}
MessageManager.SendNamedMessage(label, clientId, stream, val);
}
}
}
namespace LethalGym.Scripts
{
[HarmonyPatch]
internal class MoreEmotesPatcher
{
public static bool moreEmotes;
[HarmonyPatch(typeof(PreInitSceneScript), "Awake")]
[HarmonyPostfix]
public static void ApplyPatch()
{
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Expected O, but got Unknown
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Expected O, but got Unknown
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Expected O, but got Unknown
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Expected O, but got Unknown
if (!Plugin.IsModLoaded("MoreEmotes") || !Chainloader.PluginInfos.TryGetValue("MoreEmotes", out var value))
{
return;
}
Assembly assembly = ((object)value.Instance).GetType().Assembly;
if (assembly != null)
{
Plugin.Logger.LogWarning((object)"Applying compatibility patch for More_Emotes");
Type type = assembly.GetType("MoreEmotes.Patch.EmotePatch");
FieldInfo field = type.GetField("local", BindingFlags.Static | BindingFlags.Public);
RuntimeAnimatorController val = (RuntimeAnimatorController)field.GetValue(null);
if ((Object)(object)val != (Object)null && !(val is AnimatorOverrideController))
{
field.SetValue(null, (object?)new AnimatorOverrideController(val));
}
FieldInfo field2 = type.GetField("others", BindingFlags.Static | BindingFlags.Public);
RuntimeAnimatorController val2 = (RuntimeAnimatorController)field2.GetValue(null);
if ((Object)(object)val2 != (Object)null && !(val2 is AnimatorOverrideController))
{
field2.SetValue(null, (object?)new AnimatorOverrideController(val2));
}
moreEmotes = true;
}
}
[HarmonyPatch(typeof(StartOfRound), "Awake")]
[HarmonyPostfix]
public static void AddEmote(StartOfRound __instance)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
__instance.localClientAnimatorController = (RuntimeAnimatorController)new AnimatorOverrideController(__instance.localClientAnimatorController);
__instance.otherClientsAnimatorController = (RuntimeAnimatorController)new AnimatorOverrideController(__instance.otherClientsAnimatorController);
}
}
public class EquipmentNetworkHandler : NetworkBehaviour
{
[CompilerGenerated]
private sealed class <ChangeWeights>d__14 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public PlayerControllerB player;
public PlayerStrengthLevel psl;
public EquipmentNetworkHandler <>4__this;
private int <>s__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ChangeWeights>d__14(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
int playerStrength = psl.playerStrength;
<>s__1 = playerStrength;
switch (<>s__1)
{
case 1:
player.carryWeight = psl.originalCarryWeight / 1f;
break;
case 2:
player.carryWeight = psl.originalCarryWeight / 1.05f;
break;
case 3:
player.carryWeight = psl.originalCarryWeight / 1.1f;
break;
case 4:
player.carryWeight = psl.originalCarryWeight / 1.3f;
break;
case 5:
player.carryWeight = psl.originalCarryWeight / 1.5f;
break;
}
Debug.LogError((object)("(Grab) Middle instance: " + player.carryWeight));
if (player.carryWeight < 1f)
{
player.carryWeight = 1f;
psl.originalCarryWeight = 1f;
Debug.LogWarning((object)"Carry weight less than 1.0");
}
Debug.LogError((object)("(grab) Last original: " + psl.originalCarryWeight));
Debug.LogError((object)("(Grab) Last instance: " + player.carryWeight));
<>4__this.DoubleCheckGrabFunction(psl, GrabOrDrop: false);
psl.canDrop = false;
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <DoubleCheckGrab>d__12 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public PlayerStrengthLevel psl;
public bool GrabOrDrop;
public EquipmentNetworkHandler <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DoubleCheckGrab>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (GrabOrDrop)
{
psl.canGrab = true;
}
else
{
psl.canDrop = true;
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <UpdateDecorPrice>d__21 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public UnlockablesList unlockablesList;
public EquipmentNetworkHandler <>4__this;
private int <i>5__1;
private int <i>5__2;
private int <i>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <UpdateDecorPrice>d__21(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (!SyncedInstance<Config>.Instance.overridePrices)
{
if (SyncedInstance<Config>.Instance.strongerBody)
{
<i>5__1 = 0;
while (<i>5__1 < Unlockables.registeredUnlockables.Count)
{
if (Unlockables.registeredUnlockables[<i>5__1].unlockable == unlockablesList.unlockables[0])
{
Unlockables.UpdateUnlockablePrice(Unlockables.registeredUnlockables[<i>5__1].unlockable, 299);
}
else if (Unlockables.registeredUnlockables[<i>5__1].unlockable == unlockablesList.unlockables[1])
{
Unlockables.UpdateUnlockablePrice(Unlockables.registeredUnlockables[<i>5__1].unlockable, 299);
}
<i>5__1++;
}
}
else
{
<i>5__2 = 0;
while (<i>5__2 < Unlockables.registeredUnlockables.Count)
{
if (Unlockables.registeredUnlockables[<i>5__2].unlockable == unlockablesList.unlockables[0])
{
Unlockables.UpdateUnlockablePrice(Unlockables.registeredUnlockables[<i>5__2].unlockable, 60);
}
else if (Unlockables.registeredUnlockables[<i>5__2].unlockable == unlockablesList.unlockables[1])
{
Unlockables.UpdateUnlockablePrice(Unlockables.registeredUnlockables[<i>5__2].unlockable, 60);
}
<i>5__2++;
}
}
}
else
{
<i>5__3 = 0;
while (<i>5__3 < Unlockables.registeredUnlockables.Count)
{
if (Unlockables.registeredUnlockables[<i>5__3].unlockable == unlockablesList.unlockables[0])
{
Unlockables.UpdateUnlockablePrice(Unlockables.registeredUnlockables[<i>5__3].unlockable, SyncedInstance<Config>.Instance.benchPrice);
}
else if (Unlockables.registeredUnlockables[<i>5__3].unlockable == unlockablesList.unlockables[1])
{
Unlockables.UpdateUnlockablePrice(Unlockables.registeredUnlockables[<i>5__3].unlockable, SyncedInstance<Config>.Instance.squatPrice);
}
<i>5__3++;
}
}
setConfigs(SyncedInstance<Config>.Instance.strongerBody);
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static bool strongerBody;
public static bool overridePrices;
public static int benchPrce;
public static int squatPrice;
public static EquipmentNetworkHandler Instance { get; private set; }
public override void OnNetworkSpawn()
{
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
EquipmentNetworkHandler instance = Instance;
if (instance != null)
{
((Component)instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
}
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
}
[ServerRpc(RequireOwnership = false)]
public void SyncStrengthValuesServerRpc()
{
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
PlayerStrengthLevel component = ((Component)val).GetComponent<PlayerStrengthLevel>();
SyncStrengthValuesClientRpc(val.playerClientId, component.playerStrength, component.currentRepsInLevel, component.originalCarryWeight, strongerBody);
}
}
[ClientRpc]
public void SyncStrengthValuesClientRpc(ulong playerID, int playerStrength, int currentRepsInLevel, float carryWeight, bool strongerBody)
{
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (val.playerClientId == playerID)
{
PlayerStrengthLevel playerStrengthLevel = ((Component)val).GetComponent<PlayerStrengthLevel>();
if ((Object)(object)playerStrengthLevel == (Object)null)
{
playerStrengthLevel = ((Component)val).gameObject.AddComponent<PlayerStrengthLevel>();
}
playerStrengthLevel.playerStrength = playerStrength;
playerStrengthLevel.currentRepsInLevel = currentRepsInLevel;
playerStrengthLevel.originalCarryWeight = carryWeight;
PlayerStrengthLevel.strongerBodyStatus = strongerBody;
}
}
}
public void DoubleCheckGrabFunction(PlayerStrengthLevel psl, bool GrabOrDrop)
{
((MonoBehaviour)this).StartCoroutine(DoubleCheckGrab(psl, GrabOrDrop));
}
[IteratorStateMachine(typeof(<DoubleCheckGrab>d__12))]
public IEnumerator DoubleCheckGrab(PlayerStrengthLevel psl, bool GrabOrDrop)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DoubleCheckGrab>d__12(0)
{
<>4__this = this,
psl = psl,
GrabOrDrop = GrabOrDrop
};
}
public void ChangeWeightsFunction(PlayerControllerB player, PlayerStrengthLevel psl)
{
((MonoBehaviour)this).StartCoroutine(ChangeWeights(player, psl));
}
[IteratorStateMachine(typeof(<ChangeWeights>d__14))]
public IEnumerator ChangeWeights(PlayerControllerB player, PlayerStrengthLevel psl)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ChangeWeights>d__14(0)
{
<>4__this = this,
player = player,
psl = psl
};
}
public static void setConfigs(bool strongerBodyValue)
{
strongerBody = strongerBodyValue;
PlayerStrengthLevel[] array = Object.FindObjectsOfType<PlayerStrengthLevel>();
PlayerStrengthLevel[] array2 = array;
foreach (PlayerStrengthLevel playerStrengthLevel in array2)
{
playerStrengthLevel.UpdateConfigs(strongerBody);
}
}
[ServerRpc]
public void GrabWeightServerRpc(ulong playerID, float grabbedObjectWeight)
{
PlayerControllerB val = null;
PlayerStrengthLevel playerStrengthLevel = null;
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val2 in array2)
{
if (val2.playerClientId == playerID)
{
val = val2;
playerStrengthLevel = ((Component)val).GetComponent<PlayerStrengthLevel>();
break;
}
}
GrabWeightClientRpc(playerID, grabbedObjectWeight);
}
[ClientRpc]
public void GrabWeightClientRpc(ulong playerID, float grabbedObjectWeight)
{
PlayerControllerB val = null;
PlayerStrengthLevel playerStrengthLevel = null;
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val2 in array2)
{
if (val2.playerClientId == playerID)
{
val = val2;
playerStrengthLevel = ((Component)val).GetComponent<PlayerStrengthLevel>();
break;
}
}
playerStrengthLevel.originalCarryWeight += Mathf.Clamp(grabbedObjectWeight - 1f, 0f, 10f);
switch (playerStrengthLevel.playerStrength)
{
case 1:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1f;
break;
case 2:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.05f;
break;
case 3:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.1f;
break;
case 4:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.3f;
break;
case 5:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.5f;
break;
}
if (val.carryWeight < 1f)
{
val.carryWeight = 1f;
playerStrengthLevel.originalCarryWeight = 1f;
}
Debug.LogWarning((object)playerStrengthLevel.originalCarryWeight.ToString());
}
[ServerRpc]
public void DropWeightServerRpc(ulong playerID, float grabbedObjectWeight)
{
PlayerControllerB val = null;
PlayerStrengthLevel playerStrengthLevel = null;
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val2 in array2)
{
if (val2.playerClientId == playerID)
{
val = val2;
playerStrengthLevel = ((Component)val).GetComponent<PlayerStrengthLevel>();
break;
}
}
DropWeightClientRpc(playerID, grabbedObjectWeight);
}
[ClientRpc]
public void DropWeightClientRpc(ulong playerID, float grabbedObjectWeight)
{
PlayerControllerB val = null;
PlayerStrengthLevel playerStrengthLevel = null;
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val2 in array2)
{
if (val2.playerClientId == playerID)
{
val = val2;
playerStrengthLevel = ((Component)val).GetComponent<PlayerStrengthLevel>();
break;
}
}
playerStrengthLevel.originalCarryWeight -= Mathf.Clamp(grabbedObjectWeight - 1f, 0f, 10f);
switch (playerStrengthLevel.playerStrength)
{
case 1:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1f;
break;
case 2:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.05f;
break;
case 3:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.1f;
break;
case 4:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.3f;
break;
case 5:
val.carryWeight = playerStrengthLevel.originalCarryWeight / 1.5f;
break;
}
if (val.carryWeight < 1f)
{
val.carryWeight = 1f;
playerStrengthLevel.originalCarryWeight = 1f;
}
Debug.LogWarning((object)playerStrengthLevel.originalCarryWeight.ToString());
Debug.LogWarning((object)playerStrengthLevel.originalCarryWeight.ToString());
}
public void UpdateDecorPriceStart(UnlockablesList unlockablesList)
{
((MonoBehaviour)this).StartCoroutine(UpdateDecorPrice(unlockablesList));
}
[IteratorStateMachine(typeof(<UpdateDecorPrice>d__21))]
public IEnumerator UpdateDecorPrice(UnlockablesList unlockablesList)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <UpdateDecorPrice>d__21(0)
{
<>4__this = this,
unlockablesList = unlockablesList
};
}
[ServerRpc(RequireOwnership = false)]
public void BeginTerminalServerRPC(ulong playerID)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (val.playerClientId == playerID)
{
AnimatorOverrideController controller = (AnimatorOverrideController)val.playerBodyAnimator.runtimeAnimatorController;
Debug.LogWarning((object)((object)val.playerBodyAnimator.runtimeAnimatorController).ToString());
resetAnimations(controller);
break;
}
}
BeginTerminalClientRPC(playerID);
}
[ClientRpc]
public void BeginTerminalClientRPC(ulong playerID)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
if (val.playerClientId == playerID)
{
AnimatorOverrideController controller = (AnimatorOverrideController)val.playerBodyAnimator.runtimeAnimatorController;
resetAnimations(controller);
break;
}
}
}
public static void resetAnimations(AnimatorOverrideController controller)
{
List<KeyValuePair<AnimationClip, AnimationClip>> list = new List<KeyValuePair<AnimationClip, AnimationClip>>(controller.overridesCount);
controller.GetOverrides(list);
for (int i = 0; i < list.Count; i++)
{
list[i] = new KeyValuePair<AnimationClip, AnimationClip>(list[i].Key, null);
}
controller.ApplyOverrides((IList<KeyValuePair<AnimationClip, AnimationClip>>)list);
}
}
[HarmonyPatch]
internal class LethalGymPatches
{
public static AnimationClip benchEnter;
public static AnimationClip benchRep;
public static AnimationClip term1;
public static AnimationClip term2;
[HarmonyPatch(typeof(Terminal), "BeginUsingTerminal")]
[HarmonyPostfix]
public static void ResetAnimation(Terminal __instance)
{
EquipmentNetworkHandler equipmentNetworkHandler = Object.FindObjectOfType<EquipmentNetworkHandler>();
if ((Object)(object)equipmentNetworkHandler != (Object)null)
{
equipmentNetworkHandler.BeginTerminalServerRPC(GameNetworkManager.Instance.localPlayerController.playerClientId);
}
}
[HarmonyPatch(typeof(ShipBuildModeManager), "StoreShipObjectClientRpc")]
[HarmonyPrefix]
public static void KickPlayerOutClientRpc()
{
Equipment equipment = Object.FindObjectOfType<Equipment>();
if ((Object)(object)equipment != (Object)null)
{
equipment.LeaveEquipment();
equipment.StopSpecialAnimation();
}
}
[HarmonyPatch(typeof(ShipBuildModeManager), "StoreObjectServerRpc")]
[HarmonyPrefix]
public static void KickPlayerOutServerRpc()
{
Equipment equipment = Object.FindObjectOfType<Equipment>();
if ((Object)(object)equipment != (Object)null)
{
equipment.LeaveEquipment();
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Start")]
[HarmonyPrefix]
public static void CheckLiftName()
{
Equipment[] array = Object.FindObjectsOfType<Equipment>();
Equipment[] array2 = array;
foreach (Equipment equipment in array2)
{
if (equipment.EquipmentName == "Bench")
{
equipment.equipmentEnter = Equipment.benchEnter;
equipment.equipmentRep = Equipment.benchRep;
}
else if (equipment.EquipmentName == "Squat")
{
equipment.equipmentEnter = Equipment.squatEnter;
equipment.equipmentRep = Equipment.squatRep;
}
else
{
Debug.LogError((object)"No Name?");
}
}
}
}
[HarmonyPatch]
internal class NetworkObjectManager
{
public static AssetBundle assetBundle;
private static GameObject networkPrefab;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
public static void Init()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
if (!((Object)(object)networkPrefab != (Object)null))
{
networkPrefab = (GameObject)assetBundle.LoadAsset("Assets/MyAssets/EquipmentNetworkHandlerPrefab.prefab");
networkPrefab.AddComponent<EquipmentNetworkHandler>();
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void SpawnNetworkHandler()
{
//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)
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
}
}
}
[HarmonyPatch]
internal class StrengthValuesSaveAndLoad : NetworkBehaviour
{
private static StrengthValuesSaveAndLoad Instance;
public void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
}
[HarmonyPatch(typeof(GameNetworkManager), "SaveGameValues")]
[HarmonyPostfix]
private static void SaveStrengthValues(GameNetworkManager __instance)
{
PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
PlayerControllerB[] array2 = array;
foreach (PlayerControllerB val in array2)
{
PlayerStrengthLevel component = ((Component)val).GetComponent<PlayerStrengthLevel>();
if ((Object)(object)component != (Object)null)
{
ES3.Save<int>("PlayerStrength" + val.playerSteamId, component.playerStrength, __instance.currentSaveFileName);
ES3.Save<int>("PlayerReps" + val.playerSteamId, component.currentRepsInLevel, __instance.currentSaveFileName);
Debug.LogWarning((object)val.playerSteamId.ToString());
Debug.LogWarning((object)(component.playerStrength + " " + component.currentRepsInLevel));
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesClientRpc")]
[HarmonyPostfix]
private static void LoadStrengthValues(PlayerControllerB __instance)
{
PlayerStrengthLevel playerStrengthLevel = ((Component)__instance).gameObject.GetComponent<PlayerStrengthLevel>();
if ((Object)(object)((Component)__instance).gameObject.GetComponent<PlayerStrengthLevel>() == (Object)null)
{
playerStrengthLevel = ((Component)__instance).gameObject.AddComponent<PlayerStrengthLevel>();
}
if ((Object)(object)playerStrengthLevel != (Object)null)
{
Debug.LogWarning((object)"psl not null");
playerStrengthLevel.playerController = __instance;
string currentSaveFileName = Object.FindObjectOfType<GameNetworkManager>().currentSaveFileName;
Debug.LogWarning((object)currentSaveFileName);
playerStrengthLevel.playerStrength = ES3.Load<int>("PlayerStrength" + __instance.playerSteamId, currentSaveFileName, 1);
playerStrengthLevel.currentRepsInLevel = ES3.Load<int>("PlayerReps" + __instance.playerSteamId, currentSaveFileName, 0);
Debug.LogWarning((object)__instance.playerSteamId.ToString());
Debug.LogWarning((object)(playerStrengthLevel.playerStrength + " " + playerStrengthLevel.currentRepsInLevel));
}
Object.FindObjectOfType<EquipmentNetworkHandler>().SyncStrengthValuesServerRpc();
}
}
[HarmonyPatch]
internal class StrengthPatches : NetworkBehaviour
{
[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
[HarmonyPostfix]
private static void BeginGrab(PlayerControllerB __instance)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
PlayerStrengthLevel component = ((Component)__instance).GetComponent<PlayerStrengthLevel>();
GrabbableObject val = (GrabbableObject)Traverse.Create((object)__instance).Field("currentlyGrabbingObject").GetValue();
if (component.canGrab && PlayerStrengthLevel.strongerBodyStatus)
{
Object.FindObjectOfType<EquipmentNetworkHandler>().DoubleCheckGrabFunction(component, GrabOrDrop: true);
Object.FindObjectOfType<EquipmentNetworkHandler>().GrabWeightServerRpc(__instance.playerClientId, val.itemProperties.weight);
component.canGrab = false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "DiscardHeldObject")]
[HarmonyPrefix]
private static void BeginDrop(PlayerControllerB __instance, bool placeObject = false, NetworkObject parentObjectTo = null, Vector3 placePosition = default(Vector3), bool matchRotationOfParent = true)
{
PlayerStrengthLevel component = ((Component)__instance).GetComponent<PlayerStrengthLevel>();
if (component.canDrop && PlayerStrengthLevel.strongerBodyStatus)
{
Object.FindObjectOfType<EquipmentNetworkHandler>().ChangeWeightsFunction(__instance, component);
Object.FindObjectOfType<EquipmentNetworkHandler>().DropWeightServerRpc(__instance.playerClientId, __instance.currentlyHeldObjectServer.itemProperties.weight);
component.canDrop = false;
}
}
[HarmonyPatch(typeof(HUDManager), "Update")]
[HarmonyPostfix]
private static void ChangeHUDWeight(HUDManager __instance)
{
if (PlayerStrengthLevel.strongerBodyStatus)
{
PlayerStrengthLevel component = ((Component)GameNetworkManager.Instance.localPlayerController).gameObject.GetComponent<PlayerStrengthLevel>();
if ((Object)(object)component == (Object)null)
{
Debug.LogWarning((object)"no psl?>?>");
}
float num = Mathf.RoundToInt(Mathf.Clamp(component.originalCarryWeight - 1f, 0f, 100f) * 105f);
((TMP_Text)__instance.weightCounter).text = $"{num} lb";
__instance.weightCounterAnimator.SetFloat("weight", num / 130f);
}
}
}
[HarmonyPatch]
internal class ConfigApply : NetworkBehaviour
{
public static UnlockablesList unlockablesList;
[HarmonyPatch(typeof(PlayerControllerB), "Start")]
[HarmonyPostfix]
private static void UpdateBenchPriceController()
{
Object.FindObjectOfType<EquipmentNetworkHandler>().UpdateDecorPriceStart(unlockablesList);
}
}
}
