using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("StatManager")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("StatManager")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("179e1f3b-e093-4adf-9132-f04de1bfb69d")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace StatManager
{
[BepInPlugin("Bocon.StatManager", "Stat Manager", "1.2.0")]
public class StatManager : BaseUnityPlugin
{
private const string modGUID = "Bocon.StatManager";
private const string modeName = "Stat Manager";
private const string modVersion = "1.2.0";
private readonly Harmony harmony = new Harmony("Bocon.StatManager");
private static StatManager Instance;
internal ManualLogSource mls;
internal static ConfigEntry<int> HealthBonus;
internal static ConfigEntry<int> SpeedBonus;
internal static ConfigEntry<int> MapCountBonus;
internal static ConfigEntry<int> EnergyBonus;
internal static ConfigEntry<int> ExtraJumpBonus;
internal static ConfigEntry<int> GrabRangeBonus;
internal static ConfigEntry<int> GrabStrengthBonus;
internal static ConfigEntry<int> GrabThrowBonus;
internal static ConfigEntry<int> TumbleLaunchBonus;
internal static ConfigEntry<int> CrouchRestBonus;
internal static ConfigEntry<int> TumbleWingsBonus;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("Bocon.StatManager");
mls.LogInfo((object)"Bocon.StatManager has loaded!");
HealthBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Health", 10, "Amount of Health upgrades.");
SpeedBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Sprint Speed", 5, "Amount of Sprint Speed upgrades.");
MapCountBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Player Map Count", 1, "Amount of Player Map Count upgrades.");
EnergyBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Energy", 10, "Amount of Energy upgrades.");
ExtraJumpBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Extra Jump", 1, "Amount of Extra Jump upgrades.");
GrabRangeBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Range", 5, "Amount of Grab Range upgrades.");
GrabStrengthBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Strength", 5, "Amount of Grab Strength upgrades.");
GrabThrowBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Throw", 5, "Amount of Grab Throw upgrades.");
TumbleLaunchBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Tumble Launch", 5, "Amount of Tumble Launch upgrades.");
CrouchRestBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Crouch Rest", 2, "Amount of Crouch rest upgrades.");
TumbleWingsBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Tumble Wings", 2, "Amount of Tubmle Wing upgrades.");
harmony.PatchAll();
}
}
}
namespace StatManager.Patches
{
internal class Patch
{
[HarmonyPatch(typeof(GameDirector), "Start")]
private class GameDirectorPatch
{
private static void Postfix()
{
Object.FindObjectOfType<MonoBehaviour>().StartCoroutine(WaitForLevel());
}
}
[HarmonyPatch(typeof(RunManager), "ResetProgress")]
private class RunManagerResetPatch
{
private static void Postfix()
{
hasAppliedUpgrade = false;
}
}
[CompilerGenerated]
private sealed class <WaitForLevel>d__2 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private List<PlayerAvatar>.Enumerator <>s__1;
private PlayerAvatar <player>5__2;
private string <steamId>5__3;
private Dictionary<string, int> <upgrades>5__4;
private int <currentHealth>5__5;
private int <healthToAdd>5__6;
private int <currentSpeed>5__7;
private int <speedToAdd>5__8;
private int <currentMapCount>5__9;
private int <mapCountToAdd>5__10;
private int <currentEnergy>5__11;
private int <energyToAdd>5__12;
private int <currentExtraJump>5__13;
private int <extraJumpToAdd>5__14;
private int <currentGrabRange>5__15;
private int <grabRangeToAdd>5__16;
private int <currentGrabStrength>5__17;
private int <grabStrengthToAdd>5__18;
private int <currentGrabThrow>5__19;
private int <grabThrowToAdd>5__20;
private int <currentTumbleLaunch>5__21;
private int <tumbleLaunchToAdd>5__22;
private int <currentCrouchRest>5__23;
private int <crouchRestToAdd>5__24;
private int <currentTumbleWings>5__25;
private int <tumbleWingsToAdd>5__26;
private int <i>5__27;
private int <i>5__28;
private int <i>5__29;
private int <i>5__30;
private int <i>5__31;
private int <i>5__32;
private int <i>5__33;
private int <i>5__34;
private int <i>5__35;
private int <i>5__36;
private int <i>5__37;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForLevel>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>s__1 = default(List<PlayerAvatar>.Enumerator);
<player>5__2 = null;
<steamId>5__3 = null;
<upgrades>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if (!SemiFunc.LevelGenDone())
{
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
}
if (!hasAppliedUpgrade && SemiFunc.RunIsLevel() && SemiFunc.IsMasterClientOrSingleplayer())
{
<>s__1 = SemiFunc.PlayerGetAll().GetEnumerator();
try
{
while (<>s__1.MoveNext())
{
<player>5__2 = <>s__1.Current;
<steamId>5__3 = SemiFunc.PlayerGetSteamID(<player>5__2);
<upgrades>5__4 = StatsManager.instance.FetchPlayerUpgrades(<steamId>5__3);
<currentHealth>5__5 = (<upgrades>5__4.ContainsKey("Health") ? <upgrades>5__4["Health"] : 0);
<healthToAdd>5__6 = StatManager.HealthBonus.Value - <currentHealth>5__5;
<i>5__27 = 0;
while (<i>5__27 < <healthToAdd>5__6)
{
PunManager.instance.UpgradePlayerHealth(<steamId>5__3);
<i>5__27++;
}
<currentSpeed>5__7 = (<upgrades>5__4.ContainsKey("Speed") ? <upgrades>5__4["Speed"] : 0);
<speedToAdd>5__8 = StatManager.SpeedBonus.Value - <currentSpeed>5__7;
<i>5__28 = 0;
while (<i>5__28 < <speedToAdd>5__8)
{
PunManager.instance.UpgradePlayerSprintSpeed(<steamId>5__3);
<i>5__28++;
}
<currentMapCount>5__9 = (<upgrades>5__4.ContainsKey("Map Player Count") ? <upgrades>5__4["Map Player Count"] : 0);
<mapCountToAdd>5__10 = StatManager.MapCountBonus.Value - <currentMapCount>5__9;
<i>5__29 = 0;
while (<i>5__29 < <mapCountToAdd>5__10)
{
PunManager.instance.UpgradeMapPlayerCount(<steamId>5__3);
<i>5__29++;
}
<currentEnergy>5__11 = (<upgrades>5__4.ContainsKey("Stamina") ? <upgrades>5__4["Stamina"] : 0);
<energyToAdd>5__12 = StatManager.EnergyBonus.Value - <currentEnergy>5__11;
<i>5__30 = 0;
while (<i>5__30 < <energyToAdd>5__12)
{
PunManager.instance.UpgradePlayerEnergy(<steamId>5__3);
<i>5__30++;
}
<currentExtraJump>5__13 = (<upgrades>5__4.ContainsKey("Extra Jump") ? <upgrades>5__4["Extra Jump"] : 0);
<extraJumpToAdd>5__14 = StatManager.ExtraJumpBonus.Value - <currentExtraJump>5__13;
<i>5__31 = 0;
while (<i>5__31 < <extraJumpToAdd>5__14)
{
PunManager.instance.UpgradePlayerExtraJump(<steamId>5__3);
<i>5__31++;
}
<currentGrabRange>5__15 = (<upgrades>5__4.ContainsKey("Range") ? <upgrades>5__4["Range"] : 0);
<grabRangeToAdd>5__16 = StatManager.GrabRangeBonus.Value - <currentGrabRange>5__15;
<i>5__32 = 0;
while (<i>5__32 < <grabRangeToAdd>5__16)
{
PunManager.instance.UpgradePlayerGrabRange(<steamId>5__3);
<i>5__32++;
}
<currentGrabStrength>5__17 = (<upgrades>5__4.ContainsKey("Strength") ? <upgrades>5__4["Strength"] : 0);
<grabStrengthToAdd>5__18 = StatManager.GrabStrengthBonus.Value - <currentGrabStrength>5__17;
<i>5__33 = 0;
while (<i>5__33 < <grabStrengthToAdd>5__18)
{
PunManager.instance.UpgradePlayerGrabStrength(<steamId>5__3);
<i>5__33++;
}
<currentGrabThrow>5__19 = (<upgrades>5__4.ContainsKey("Throw") ? <upgrades>5__4["Throw"] : 0);
<grabThrowToAdd>5__20 = StatManager.GrabThrowBonus.Value - <currentGrabThrow>5__19;
<i>5__34 = 0;
while (<i>5__34 < <grabThrowToAdd>5__20)
{
PunManager.instance.UpgradePlayerThrowStrength(<steamId>5__3);
<i>5__34++;
}
<currentTumbleLaunch>5__21 = (<upgrades>5__4.ContainsKey("Launch") ? <upgrades>5__4["Launch"] : 0);
<tumbleLaunchToAdd>5__22 = StatManager.TumbleLaunchBonus.Value - <currentTumbleLaunch>5__21;
<i>5__35 = 0;
while (<i>5__35 < <tumbleLaunchToAdd>5__22)
{
PunManager.instance.UpgradePlayerTumbleLaunch(<steamId>5__3);
<i>5__35++;
}
<currentCrouchRest>5__23 = (<upgrades>5__4.ContainsKey("Crouch Rest") ? <upgrades>5__4["Crouch Rest"] : 0);
<crouchRestToAdd>5__24 = StatManager.CrouchRestBonus.Value - <currentCrouchRest>5__23;
<i>5__36 = 0;
while (<i>5__36 < <crouchRestToAdd>5__24)
{
PunManager.instance.UpgradePlayerCrouchRest(<steamId>5__3);
<i>5__36++;
}
<currentTumbleWings>5__25 = (<upgrades>5__4.ContainsKey("Tumble Wings") ? <upgrades>5__4["Tumble Wings"] : 0);
<tumbleWingsToAdd>5__26 = StatManager.TumbleWingsBonus.Value - <currentTumbleWings>5__25;
<i>5__37 = 0;
while (<i>5__37 < <tumbleWingsToAdd>5__26)
{
PunManager.instance.UpgradePlayerTumbleWings(<steamId>5__3);
<i>5__37++;
}
<steamId>5__3 = null;
<upgrades>5__4 = null;
<player>5__2 = null;
}
}
finally
{
((IDisposable)<>s__1).Dispose();
}
<>s__1 = default(List<PlayerAvatar>.Enumerator);
hasAppliedUpgrade = 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();
}
}
private static bool hasAppliedUpgrade;
[IteratorStateMachine(typeof(<WaitForLevel>d__2))]
private static IEnumerator WaitForLevel()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForLevel>d__2(0);
}
}
}
