using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
[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("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EmpressSharedUpgrades")]
[assembly: AssemblyTitle("EmpressSharedUpgrades")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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]
[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;
}
}
[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 Empress.SharedUpgrades
{
internal static class RepOLibCompat
{
private static MethodInfo? _miAddLevel;
private static bool _installed;
[ThreadStatic]
private static bool _localGuard;
internal static void TryInstall(Harmony harmony, ManualLogSource log)
{
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
if (_installed)
{
return;
}
Type type = AccessTools.TypeByName("REPOLib.Modules.PlayerUpgrade");
if (type == null)
{
log.LogDebug((object)"[SharedUpgrades:REPOLibCompat] REPOLib not present; skipping compatibility hook.");
return;
}
_miAddLevel = AccessTools.Method(type, "AddLevel", new Type[2]
{
typeof(PlayerAvatar),
typeof(int)
}, (Type[])null);
if (_miAddLevel == null)
{
log.LogWarning((object)"[SharedUpgrades:REPOLibCompat] Could not find PlayerUpgrade.AddLevel(PlayerAvatar,int); skipping.");
return;
}
HarmonyMethod val = new HarmonyMethod(typeof(RepOLibCompat), "AddLevelPostfix", (Type[])null);
harmony.Patch((MethodBase)_miAddLevel, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_installed = true;
log.LogInfo((object)"[SharedUpgrades:REPOLibCompat] Hooked REPOLib.Modules.PlayerUpgrade.AddLevel for team-share propagation.");
}
private static void AddLevelPostfix(object __instance, PlayerAvatar playerAvatar, int amount)
{
if (__instance == null || (Object)(object)playerAvatar == (Object)null || amount == 0 || _localGuard || !Empress_SharedUpgrades.Ready() || !Empress_SharedUpgrades.IsMasterOrSingle() || Empress_SharedUpgrades.Guard || MoreUpgradesTeamSharingEnabledFor(__instance))
{
return;
}
try
{
_localGuard = true;
Empress_SharedUpgrades.Guard = true;
string text = SemiFunc.PlayerGetSteamID(playerAvatar);
if (string.IsNullOrEmpty(text))
{
return;
}
foreach (string item in Empress_SharedUpgrades.AllSteamIDs())
{
if (!string.IsNullOrEmpty(item) && !string.Equals(item, text, StringComparison.Ordinal))
{
PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(item);
if (Object.op_Implicit((Object)(object)val))
{
_miAddLevel?.Invoke(__instance, new object[2] { val, amount });
}
}
}
}
catch (Exception arg)
{
Empress_SharedUpgrades.Logger.LogWarning((object)$"[SharedUpgrades:REPOLibCompat] Mirror failed: {arg}");
}
finally
{
Empress_SharedUpgrades.Guard = false;
_localGuard = false;
}
}
private static bool MoreUpgradesTeamSharingEnabledFor(object playerUpgrade)
{
try
{
Type type = AccessTools.TypeByName("MoreUpgrades.Plugin");
if (type == null)
{
return false;
}
object obj = AccessTools.Field(type, "instance")?.GetValue(null);
if (obj == null)
{
return false;
}
FieldInfo fieldInfo = AccessTools.Field(type, "upgradeItems");
if (fieldInfo == null)
{
return false;
}
if (!(fieldInfo.GetValue(obj) is IEnumerable enumerable))
{
return false;
}
foreach (object item in enumerable)
{
if (item == null)
{
continue;
}
object obj2 = AccessTools.Field(item.GetType(), "playerUpgrade")?.GetValue(item);
if (obj2 != playerUpgrade)
{
continue;
}
MethodInfo methodInfo = AccessTools.Method(item.GetType(), "HasConfig", new Type[1] { typeof(string) }, (Type[])null);
if (methodInfo == null)
{
return false;
}
if (!(bool)methodInfo.Invoke(item, new object[1] { "Allow Team Upgrades" }))
{
return false;
}
MethodInfo methodInfo2 = AccessTools.Method(item.GetType(), "GetConfig", new Type[1] { typeof(string) }, (Type[])null);
if (methodInfo2 == null)
{
return false;
}
MethodInfo methodInfo3 = methodInfo2.MakeGenericMethod(typeof(bool));
return (bool)methodInfo3.Invoke(item, new object[1] { "Allow Team Upgrades" });
}
}
catch
{
return false;
}
return false;
}
internal static void BootstrapFrom(Empress_SharedUpgrades owner)
{
TryInstall(owner.Harmony, Empress_SharedUpgrades.Logger);
}
}
[BepInPlugin("Empress.Empress_SharedUpgrades", "Empress_SharedUpgrades", "1.2.1")]
public class Empress_SharedUpgrades : BaseUnityPlugin, IOnEventCallback
{
internal enum UpgType
{
Health,
Energy,
ExtraJump,
MapPlayerCount,
SprintSpeed,
GrabStrength,
ThrowStrength,
GrabRange,
CrouchRest,
TumbleClimb,
TumbleLaunch,
TumbleWings
}
[CompilerGenerated]
private sealed class <AllSteamIDs>d__21 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
{
private int <>1__state;
private string <>2__current;
private int <>l__initialThreadId;
private List<PlayerAvatar> <list>5__1;
private List<PlayerAvatar>.Enumerator <>s__2;
private PlayerAvatar <p>5__3;
string IEnumerator<string>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AllSteamIDs>d__21(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<list>5__1 = null;
<>s__2 = default(List<PlayerAvatar>.Enumerator);
<p>5__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if ((Object)(object)GameDirector.instance == (Object)null)
{
return false;
}
<list>5__1 = GameDirector.instance.PlayerList;
if (<list>5__1 == null)
{
return false;
}
<>s__2 = <list>5__1.GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
<p>5__3 = null;
break;
}
while (<>s__2.MoveNext())
{
<p>5__3 = <>s__2.Current;
if ((Object)(object)<p>5__3 == (Object)null)
{
continue;
}
<>2__current = SemiFunc.PlayerGetSteamID(<p>5__3);
<>1__state = 1;
return true;
}
<>m__Finally1();
<>s__2 = default(List<PlayerAvatar>.Enumerator);
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>s__2).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<string> IEnumerable<string>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <AllSteamIDs>d__21(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<string>)this).GetEnumerator();
}
}
internal static bool Guard;
private bool _callbacks;
private const byte EventCode = 195;
internal static Empress_SharedUpgrades Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} loaded");
}
private void OnDestroy()
{
if (_callbacks)
{
PhotonNetwork.RemoveCallbackTarget((object)this);
}
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
if (Ready())
{
if (!_callbacks)
{
PhotonNetwork.AddCallbackTarget((object)this);
_callbacks = true;
}
}
else if (_callbacks)
{
PhotonNetwork.RemoveCallbackTarget((object)this);
_callbacks = false;
}
}
internal void Patch()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
RepOLibCompat.BootstrapFrom(this);
}
internal static bool Ready()
{
if (!PhotonNetwork.IsConnected)
{
return false;
}
if (!PhotonNetwork.InRoom)
{
return false;
}
if (SemiFunc.MenuLevel())
{
return false;
}
if ((Object)(object)LevelGenerator.Instance == (Object)null)
{
return false;
}
if (!LevelGenerator.Instance.Generated)
{
return false;
}
PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
if (!Object.op_Implicit((Object)(object)val))
{
return false;
}
return true;
}
internal static bool IsMasterOrSingle()
{
return SemiFunc.IsMasterClientOrSingleplayer();
}
[IteratorStateMachine(typeof(<AllSteamIDs>d__21))]
internal static IEnumerable<string> AllSteamIDs()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AllSteamIDs>d__21(-2);
}
internal static void Propagate(PunManager pm, string sourceSteamID, int value, Action<PunManager, string, int> applier)
{
if (!Ready() || !IsMasterOrSingle() || Guard || value == 0)
{
return;
}
Guard = true;
try
{
foreach (string item in AllSteamIDs())
{
if (!string.IsNullOrEmpty(item) && !(item == sourceSteamID))
{
applier(pm, item, value);
}
}
}
finally
{
Guard = false;
}
}
internal static void BroadcastRightAway(string sourceSteamID, int value, UpgType type)
{
//IL_0053: 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)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
if (Ready() && IsMasterOrSingle() && !Guard && value != 0)
{
object[] array = new object[3]
{
sourceSteamID,
(int)type,
value
};
RaiseEventOptions val = new RaiseEventOptions
{
Receivers = (ReceiverGroup)0
};
PhotonNetwork.RaiseEvent((byte)195, (object)array, val, SendOptions.SendReliable);
}
}
public void OnEvent(EventData photonEvent)
{
if (!Ready() || photonEvent.Code != 195 || !(photonEvent.CustomData is object[] array) || array.Length < 3)
{
return;
}
string a = array[0] as string;
UpgType type = (UpgType)(int)array[1];
int value = (int)array[2];
PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val))
{
string b = SemiFunc.PlayerGetSteamID(val);
if (!string.Equals(a, b, StringComparison.Ordinal))
{
ApplyRightAwayLocal(type, value);
}
}
}
internal static void ApplyRightAwayLocal(UpgType type, int value)
{
switch (type)
{
case UpgType.Health:
{
PlayerAvatar val8 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val8))
{
int num3 = 20 * value;
PlayerHealth playerHealth = val8.playerHealth;
playerHealth.maxHealth += num3;
if (num3 >= 0)
{
val8.playerHealth.Heal(num3, false);
}
else
{
val8.playerHealth.Hurt(-num3, false, -1);
}
}
break;
}
case UpgType.Energy:
{
int num = 10 * value;
PlayerController instance = PlayerController.instance;
instance.EnergyStart += (float)num;
float num2 = PlayerController.instance.EnergyCurrent + (float)num;
if (num2 > PlayerController.instance.EnergyStart)
{
num2 = PlayerController.instance.EnergyStart;
}
if (num2 < 0f)
{
num2 = 0f;
}
PlayerController.instance.EnergyCurrent = num2;
break;
}
case UpgType.ExtraJump:
{
PlayerController instance4 = PlayerController.instance;
instance4.JumpExtra += value;
break;
}
case UpgType.MapPlayerCount:
{
PlayerAvatar val6 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val6))
{
val6.upgradeMapPlayerCount += value;
}
break;
}
case UpgType.SprintSpeed:
{
PlayerController instance2 = PlayerController.instance;
instance2.SprintSpeed += (float)value;
PlayerController instance3 = PlayerController.instance;
instance3.SprintSpeedUpgrades += (float)value;
break;
}
case UpgType.GrabStrength:
{
PlayerAvatar val2 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val2))
{
PhysGrabber physGrabber = val2.physGrabber;
physGrabber.grabStrength += 0.2f * (float)value;
}
break;
}
case UpgType.ThrowStrength:
{
PlayerAvatar val9 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val9))
{
PhysGrabber physGrabber3 = val9.physGrabber;
physGrabber3.throwStrength += 0.3f * (float)value;
}
break;
}
case UpgType.GrabRange:
{
PlayerAvatar val7 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val7))
{
PhysGrabber physGrabber2 = val7.physGrabber;
physGrabber2.grabRange += (float)value;
}
break;
}
case UpgType.CrouchRest:
{
PlayerAvatar val5 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val5))
{
val5.upgradeCrouchRest += (float)value;
}
break;
}
case UpgType.TumbleClimb:
{
PlayerAvatar val4 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val4))
{
val4.upgradeTumbleClimb += (float)value;
}
break;
}
case UpgType.TumbleLaunch:
{
PlayerAvatar val3 = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val3))
{
PlayerTumble tumble = val3.tumble;
tumble.tumbleLaunch += value;
}
break;
}
case UpgType.TumbleWings:
{
PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
if (Object.op_Implicit((Object)(object)val))
{
val.upgradeTumbleWings += (float)value;
}
break;
}
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerHealth")]
public static class Patch_UpgradePlayerHealth
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeHealth = StatsManager.instance.playerUpgradeHealth;
playerUpgradeHealth.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerHealth(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.Health);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerEnergy")]
public static class Patch_UpgradePlayerEnergy
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeStamina = StatsManager.instance.playerUpgradeStamina;
playerUpgradeStamina.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerEnergy(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.Energy);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerExtraJump")]
public static class Patch_UpgradePlayerExtraJump
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeExtraJump = StatsManager.instance.playerUpgradeExtraJump;
playerUpgradeExtraJump.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerExtraJump(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.ExtraJump);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradeMapPlayerCount")]
public static class Patch_UpgradeMapPlayerCount
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeMapPlayerCount = StatsManager.instance.playerUpgradeMapPlayerCount;
playerUpgradeMapPlayerCount.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradeMapPlayerCount(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.MapPlayerCount);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerSprintSpeed")]
public static class Patch_UpgradePlayerSprintSpeed
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeSpeed = StatsManager.instance.playerUpgradeSpeed;
playerUpgradeSpeed.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerSprintSpeed(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.SprintSpeed);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerGrabStrength")]
public static class Patch_UpgradePlayerGrabStrength
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeStrength = StatsManager.instance.playerUpgradeStrength;
playerUpgradeStrength.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerGrabStrength(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.GrabStrength);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerThrowStrength")]
public static class Patch_UpgradePlayerThrowStrength
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeThrow = StatsManager.instance.playerUpgradeThrow;
playerUpgradeThrow.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerThrowStrength(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.ThrowStrength);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerGrabRange")]
public static class Patch_UpgradePlayerGrabRange
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeRange = StatsManager.instance.playerUpgradeRange;
playerUpgradeRange.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerGrabRange(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.GrabRange);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerCrouchRest")]
public static class Patch_UpgradePlayerCrouchRest
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeCrouchRest = StatsManager.instance.playerUpgradeCrouchRest;
playerUpgradeCrouchRest.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerCrouchRest(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.CrouchRest);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerTumbleClimb")]
public static class Patch_UpgradePlayerTumbleClimb
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeTumbleClimb = StatsManager.instance.playerUpgradeTumbleClimb;
playerUpgradeTumbleClimb.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerTumbleClimb(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.TumbleClimb);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerTumbleLaunch")]
public static class Patch_UpgradePlayerTumbleLaunch
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeLaunch = StatsManager.instance.playerUpgradeLaunch;
playerUpgradeLaunch.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerTumbleLaunch(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.TumbleLaunch);
}
}
}
[HarmonyPatch(typeof(PunManager), "UpgradePlayerTumbleWings")]
public static class Patch_UpgradePlayerTumbleWings
{
public static void Prefix(string _steamID, ref int __state)
{
Dictionary<string, int> playerUpgradeTumbleWings = StatsManager.instance.playerUpgradeTumbleWings;
playerUpgradeTumbleWings.TryGetValue(_steamID, out __state);
}
public static void Postfix(PunManager __instance, string _steamID, int __result, int __state)
{
int num = __result - __state;
if (num != 0)
{
Empress_SharedUpgrades.Propagate(__instance, _steamID, num, delegate(PunManager pm, string id, int v)
{
pm.UpgradePlayerTumbleWings(id, v);
});
Empress_SharedUpgrades.BroadcastRightAway(_steamID, num, Empress_SharedUpgrades.UpgType.TumbleWings);
}
}
}
}
