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 System.Threading;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using Zorro.Core;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("PeakClassMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PeakClassMod")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("68e93fcd-af72-447e-8fcc-2e7429a66921")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PeakClassMod;
public class Class1
{
}
[BepInPlugin("com.peakmod.classmod", "PEAK Class Mod", "1.0.0")]
public class PeakClassModPlugin : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <LogAllHatsDelayed>d__11 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public PeakClassModPlugin <>4__this;
private ManualLogSource <logger>5__1;
private CustomizationOption[] <hats>5__2;
private int <i>5__3;
private CustomizationOption <hat>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LogAllHatsDelayed>d__11(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<logger>5__1 = null;
<hats>5__2 = null;
<hat>5__4 = null;
<>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
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(10f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<logger>5__1 = Logger.CreateLogSource("PeakClassMod");
<logger>5__1.LogInfo((object)"[ClassMod] ===== HAT LIST START =====");
<hats>5__2 = Singleton<Customization>.Instance?.hats;
if (<hats>5__2 != null)
{
<logger>5__1.LogInfo((object)$"[ClassMod] Total hats found: {<hats>5__2.Length}");
<i>5__3 = 0;
while (<i>5__3 < <hats>5__2.Length)
{
<hat>5__4 = <hats>5__2[<i>5__3];
if ((Object)(object)<hat>5__4 != (Object)null)
{
<logger>5__1.LogInfo((object)$"[ClassMod] Hat[{<i>5__3}]: Name='{((Object)<hat>5__4).name}', Type='{<hat>5__4.type}', RequiredAchievement='{<hat>5__4.requiredAchievement}'");
}
else
{
<logger>5__1.LogInfo((object)$"[ClassMod] Hat[{<i>5__3}]: NULL");
}
<hat>5__4 = null;
<i>5__3++;
}
}
else
{
<logger>5__1.LogWarning((object)"[ClassMod] No hats found! Customization singleton might not be loaded yet.");
}
<logger>5__1.LogInfo((object)"[ClassMod] ===== HAT LIST END =====");
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 Harmony harmony;
public static string currentClass = "None";
public static bool scoutActive = false;
public static bool medicActive = false;
public static bool techPriestActive = false;
public static bool mushroomancerActive = false;
public static bool greatEpeeActive = false;
public static bool rogueActive = false;
public static bool eddieActive = false;
public static bool billActive = false;
private void Awake()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
harmony = new Harmony("com.peakmod.classmod");
harmony.PatchAll();
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
val.LogInfo((object)"[ClassMod] Harmony patches applied!");
((MonoBehaviour)this).StartCoroutine(LogAllHatsDelayed());
}
[IteratorStateMachine(typeof(<LogAllHatsDelayed>d__11))]
private IEnumerator LogAllHatsDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LogAllHatsDelayed>d__11(0)
{
<>4__this = this
};
}
private void OnDestroy()
{
Harmony obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
}
}
[HarmonyPatch(typeof(CharacterCustomization), "SetCharacterHat")]
public class CharacterCustomization_SetCharacterHat_Patch
{
[CompilerGenerated]
private sealed class <RefreshUIDelayed>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RefreshUIDelayed>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.bar != (Object)null)
{
GUIManager.instance.bar.ChangeBar();
}
if (ClassManager.IsScoutActive() && (Object)(object)Character.localCharacter != (Object)null)
{
<>2__current = null;
<>1__state = 2;
return true;
}
break;
case 2:
<>1__state = -1;
if ((Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.bar != (Object)null)
{
GUIManager.instance.bar.ChangeBar();
}
break;
}
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 void Postfix(int index)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
string text = "Unknown";
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && index >= 0 && index < array.Length)
{
CustomizationOption obj = array[index];
text = ((obj != null) ? ((Object)obj).name : null) ?? "NULL";
}
val.LogInfo((object)$"[ClassMod] Hat changed to index: {index}, name: {text}");
switch (index)
{
case 12:
ClassManager.ActivateScoutClass();
val.LogInfo((object)"[ClassMod] Scout class activated!");
return;
case 7:
ClassManager.ActivateMedicClass();
val.LogInfo((object)"[ClassMod] Medic class activated!");
return;
case 10:
ClassManager.ActivateTechPriestClass();
val.LogInfo((object)"[ClassMod] Tech-Priest class activated!");
return;
}
switch (text)
{
case "Hat_Mushroom":
ClassManager.ActivateMushroomancerClass();
val.LogInfo((object)"[ClassMod] Mushroomancer class activated!");
return;
case "Hat_Propeller":
ClassManager.ActivateGreatEpeeClass();
val.LogInfo((object)"[ClassMod] Great Épée class activated!");
return;
case "Hat_NinjaHeadband":
ClassManager.ActivateRogueClass();
val.LogInfo((object)"[ClassMod] Rogue class activated!");
return;
}
ClassManager.DeactivateAllClasses();
val.LogInfo((object)"[ClassMod] All classes deactivated!");
if ((Object)(object)Character.localCharacter != (Object)null)
{
((MonoBehaviour)Character.localCharacter).StartCoroutine(RefreshUIDelayed());
}
}
[IteratorStateMachine(typeof(<RefreshUIDelayed>d__1))]
private static IEnumerator RefreshUIDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RefreshUIDelayed>d__1(0);
}
}
[HarmonyPatch(typeof(Character), "UseStamina")]
public class Character_UseStamina_Patch
{
private static void Prefix(Character __instance, ref float usage, bool useBonusStamina)
{
if (ClassManager.IsScoutActive())
{
usage *= 0.75f;
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
public class CharacterAfflictions_AddStatus_Scout_Patch
{
private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Invalid comparison between Unknown and I4
Character character = __instance.character;
if ((Object)(object)character == (Object)null || !character.IsLocal)
{
return true;
}
if (ClassManager.IsScoutActive() && (int)statusType == 1)
{
amount *= 1.5f;
}
return true;
}
}
[HarmonyPatch(typeof(Character), "ClampStamina")]
public class Character_ClampStamina_Patch
{
private static void Postfix(Character __instance)
{
if (ClassManager.IsScoutActive() && __instance.IsLocal && (Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.bar != (Object)null)
{
GUIManager.instance.bar.ChangeBar();
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "UpdateNormalStatuses")]
public class CharacterAfflictions_UpdateNormalStatuses_Patch
{
private static void Prefix(CharacterAfflictions __instance)
{
if (!((Object)(object)__instance.character != (Object)null))
{
return;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.character).photonView.Owner) : null);
if (val == null)
{
return;
}
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
__instance.currentStatuses[1] = 0f;
}
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "SetStatus")]
public class CharacterAfflictions_SetStatus_Patch
{
[CompilerGenerated]
private sealed class <RefreshUIDelayed>d__2 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RefreshUIDelayed>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.bar != (Object)null)
{
GUIManager.instance.bar.ChangeBar();
}
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 void Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Invalid comparison between Unknown and I4
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Invalid comparison between Unknown and I4
if ((int)statusType == 5 && amount == 0f)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
val.LogInfo((object)$"[ClassMod] SetStatus called for Curse, amount: {amount}");
if ((Object)(object)__instance.character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val2 = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.character).photonView.Owner) : null);
if (val2 != null)
{
int currentHat = val2.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Medic" || name == "MedicHelmet")
{
amount = __instance.GetCurrentStatus((STATUSTYPE)5);
val.LogInfo((object)$"[ClassMod] Prevented curse removal for Medic class character: {__instance.character.characterName}, keeping value: {amount}");
}
}
}
}
}
if (!((Object)(object)__instance.character != (Object)null) || ((int)statusType != 7 && (int)statusType != 1))
{
return;
}
PersistentPlayerDataService service2 = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val3 = ((service2 != null) ? service2.GetPlayerData(((MonoBehaviourPun)__instance.character).photonView.Owner) : null);
if (val3 == null)
{
return;
}
int currentHat2 = val3.customizationData.currentHat;
CustomizationOption[] array2 = Singleton<Customization>.Instance?.hats;
if (array2 != null && currentHat2 >= 0 && currentHat2 < array2.Length)
{
string name2 = ((Object)array2[currentHat2]).name;
if (name2 == "Hat_Crab")
{
amount = 0f;
}
}
}
private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount)
{
}
[IteratorStateMachine(typeof(<RefreshUIDelayed>d__2))]
private static IEnumerator RefreshUIDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RefreshUIDelayed>d__2(0);
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "SubtractStatus")]
public class CharacterAfflictions_SubtractStatus_Patch
{
private static void Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC, ref bool __state)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
__state = false;
if ((int)statusType != 5)
{
return;
}
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
val.LogInfo((object)$"[ClassMod] SubtractStatus called for Curse, amount: {amount}");
if (!((Object)(object)__instance.character != (Object)null))
{
return;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val2 = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.character).photonView.Owner) : null);
if (val2 == null)
{
return;
}
int currentHat = val2.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Medic" || name == "MedicHelmet")
{
__state = true;
val.LogInfo((object)"[ClassMod] Medic class detected, will prevent curse removal");
}
}
}
private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC, bool __state)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
if (__state && (int)statusType == 5)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
float num = 0.12f;
__instance.currentStatuses[5] = num;
val.LogInfo((object)$"[ClassMod] Restored curse effect to {num} for Medic class character: {__instance.character.characterName}");
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
public class CharacterAfflictions_AddStatus_Patch
{
[CompilerGenerated]
private sealed class <RefreshUIDelayed>d__2 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RefreshUIDelayed>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.bar != (Object)null)
{
GUIManager.instance.bar.ChangeBar();
}
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 Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
if ((int)statusType == 1 && (Object)(object)__instance.character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.character).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
amount = 0f;
}
}
}
}
return true;
}
private static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC)
{
}
[IteratorStateMachine(typeof(<RefreshUIDelayed>d__2))]
private static IEnumerator RefreshUIDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RefreshUIDelayed>d__2(0);
}
}
[HarmonyPatch(typeof(RunManager), "StartRun")]
public class RunManager_StartRun_Patch
{
[CompilerGenerated]
private sealed class <GiveMedkitsDelayed>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private ManualLogSource <logger>5__1;
private int <maxWaitTime>5__2;
private int <currentWait>5__3;
private HashSet<Character> <processedCharacters>5__4;
private bool <allPlayersHaveCharacters>5__5;
private Player[] <>s__6;
private int <>s__7;
private Player <player>5__8;
private Player[] <>s__9;
private int <>s__10;
private Player <player>5__11;
private Character <character>5__12;
private List<Character>.Enumerator <>s__13;
private Character <character>5__14;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GiveMedkitsDelayed>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<logger>5__1 = null;
<processedCharacters>5__4 = null;
<>s__6 = null;
<player>5__8 = null;
<>s__9 = null;
<player>5__11 = null;
<character>5__12 = null;
<>s__13 = default(List<Character>.Enumerator);
<character>5__14 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
//IL_015e: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (!PhotonNetwork.IsMasterClient)
{
return false;
}
<logger>5__1 = Logger.CreateLogSource("PeakClassMod");
<logger>5__1.LogInfo((object)"[ClassMod] Checking for Medic class characters...");
<maxWaitTime>5__2 = 30;
<currentWait>5__3 = 0;
break;
case 2:
<>1__state = -1;
<currentWait>5__3++;
break;
}
if (<currentWait>5__3 < <maxWaitTime>5__2)
{
<allPlayersHaveCharacters>5__5 = true;
<>s__6 = PhotonNetwork.PlayerList;
for (<>s__7 = 0; <>s__7 < <>s__6.Length; <>s__7++)
{
<player>5__8 = <>s__6[<>s__7];
if ((Object)(object)PlayerHandler.GetPlayerCharacter(<player>5__8) == (Object)null)
{
<allPlayersHaveCharacters>5__5 = false;
break;
}
<player>5__8 = null;
}
<>s__6 = null;
if (!<allPlayersHaveCharacters>5__5)
{
<logger>5__1.LogInfo((object)$"[ClassMod] Waiting for all players to load characters... ({<currentWait>5__3}/{<maxWaitTime>5__2})");
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 2;
return true;
}
<logger>5__1.LogInfo((object)"[ClassMod] All players have characters loaded!");
}
<processedCharacters>5__4 = new HashSet<Character>();
<>s__9 = PhotonNetwork.PlayerList;
for (<>s__10 = 0; <>s__10 < <>s__9.Length; <>s__10++)
{
<player>5__11 = <>s__9[<>s__10];
<character>5__12 = PlayerHandler.GetPlayerCharacter(<player>5__11);
if (!((Object)(object)<character>5__12 == (Object)null) && !<character>5__12.isBot && !<processedCharacters>5__4.Contains(<character>5__12))
{
<logger>5__1.LogInfo((object)$"[ClassMod] Checking character via PlayerList: {<character>5__12.characterName} (IsLocal: {<character>5__12.IsLocal})");
if (IsMedicClass(<character>5__12))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Medic class via PlayerList: " + <character>5__12.characterName));
GiveFirstAidKit(<character>5__12);
<processedCharacters>5__4.Add(<character>5__12);
}
else if (IsTechPriestClass(<character>5__12))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Tech-Priest class via PlayerList: " + <character>5__12.characterName));
GiveChainShooters(<character>5__12);
<processedCharacters>5__4.Add(<character>5__12);
}
else if (IsMushroomancerClass(<character>5__12))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Mushroomancer class via PlayerList: " + <character>5__12.characterName));
GiveMushroomancerItems(<character>5__12);
<processedCharacters>5__4.Add(<character>5__12);
}
else if (IsRogueClass(<character>5__12))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Rogue class via PlayerList: " + <character>5__12.characterName));
GiveRogueItems(<character>5__12);
<processedCharacters>5__4.Add(<character>5__12);
}
else
{
<logger>5__1.LogInfo((object)("[ClassMod] Character " + <character>5__12.characterName + " is NOT Medic, Tech-Priest, Mushroomancer, or Rogue class"));
}
<character>5__12 = null;
<player>5__11 = null;
}
}
<>s__9 = null;
<logger>5__1.LogInfo((object)$"[ClassMod] Character.AllCharacters count: {Character.AllCharacters.Count}");
<>s__13 = Character.AllCharacters.GetEnumerator();
try
{
while (<>s__13.MoveNext())
{
<character>5__14 = <>s__13.Current;
if (!((Object)(object)<character>5__14 == (Object)null) && !<character>5__14.isBot && !<processedCharacters>5__4.Contains(<character>5__14))
{
<logger>5__1.LogInfo((object)$"[ClassMod] Checking character via AllCharacters: {<character>5__14.characterName} (IsLocal: {<character>5__14.IsLocal})");
if (IsMedicClass(<character>5__14))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Medic class via AllCharacters: " + <character>5__14.characterName));
GiveFirstAidKit(<character>5__14);
<processedCharacters>5__4.Add(<character>5__14);
}
else if (IsTechPriestClass(<character>5__14))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Tech-Priest class via AllCharacters: " + <character>5__14.characterName));
GiveChainShooters(<character>5__14);
<processedCharacters>5__4.Add(<character>5__14);
}
else if (IsMushroomancerClass(<character>5__14))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Mushroomancer class via AllCharacters: " + <character>5__14.characterName));
GiveMushroomancerItems(<character>5__14);
<processedCharacters>5__4.Add(<character>5__14);
}
else if (IsRogueClass(<character>5__14))
{
<logger>5__1.LogInfo((object)("[ClassMod] Found Rogue class via AllCharacters: " + <character>5__14.characterName));
GiveRogueItems(<character>5__14);
<processedCharacters>5__4.Add(<character>5__14);
}
else
{
<logger>5__1.LogInfo((object)("[ClassMod] Character " + <character>5__14.characterName + " is NOT Medic, Tech-Priest, Mushroomancer, or Rogue class (AllCharacters)"));
}
<character>5__14 = null;
}
}
}
finally
{
((IDisposable)<>s__13).Dispose();
}
<>s__13 = default(List<Character>.Enumerator);
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 void Postfix()
{
((MonoBehaviour)RunManager.Instance).StartCoroutine(GiveMedkitsDelayed());
}
[IteratorStateMachine(typeof(<GiveMedkitsDelayed>d__1))]
private static IEnumerator GiveMedkitsDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GiveMedkitsDelayed>d__1(0);
}
private static bool IsMedicClass(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.refs?.customization == (Object)null)
{
return false;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)character).photonView.Owner) : null);
if (val == null)
{
return false;
}
int currentHat = val.customizationData.currentHat;
ManualLogSource val2 = Logger.CreateLogSource("PeakClassMod");
val2.LogInfo((object)$"[ClassMod] Character {character.characterName} hat index: {currentHat}");
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array == null || currentHat < 0 || currentHat >= array.Length)
{
return false;
}
string name = ((Object)array[currentHat]).name;
val2.LogInfo((object)("[ClassMod] Hat name: " + name));
return name == "Hat_Medic" || name == "MedicHelmet";
}
private static bool IsTechPriestClass(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.refs?.customization == (Object)null)
{
return false;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)character).photonView.Owner) : null);
if (val == null)
{
return false;
}
int currentHat = val.customizationData.currentHat;
ManualLogSource val2 = Logger.CreateLogSource("PeakClassMod");
val2.LogInfo((object)$"[ClassMod] Character {character.characterName} hat index: {currentHat}");
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array == null || currentHat < 0 || currentHat >= array.Length)
{
return false;
}
string name = ((Object)array[currentHat]).name;
val2.LogInfo((object)("[ClassMod] Hat name: " + name));
return name == "Hat_Crab";
}
private static bool IsMushroomancerClass(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.refs?.customization == (Object)null)
{
return false;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)character).photonView.Owner) : null);
if (val == null)
{
return false;
}
int currentHat = val.customizationData.currentHat;
ManualLogSource val2 = Logger.CreateLogSource("PeakClassMod");
val2.LogInfo((object)$"[ClassMod] Character {character.characterName} hat index: {currentHat}");
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array == null || currentHat < 0 || currentHat >= array.Length)
{
return false;
}
string name = ((Object)array[currentHat]).name;
val2.LogInfo((object)("[ClassMod] Hat name: " + name));
return name == "Hat_Mushroom";
}
private static bool IsRogueClass(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)character.refs?.customization == (Object)null)
{
return false;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)character).photonView.Owner) : null);
if (val == null)
{
return false;
}
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array == null || currentHat < 0 || currentHat >= array.Length)
{
return false;
}
string name = ((Object)array[currentHat]).name;
return name == "Hat_NinjaHeadband";
}
private static void GiveFirstAidKit(Character character)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
Item val2 = null;
Item[] array = Resources.FindObjectsOfTypeAll<Item>();
foreach (Item val3 in array)
{
if (((Object)val3).name == "FirstAidKit")
{
val2 = val3;
val.LogInfo((object)$"[ClassMod] Found FirstAidKit with ID: {val3.itemID}");
break;
}
}
if ((Object)(object)val2 == (Object)null)
{
val.LogError((object)"[ClassMod] Could not find FirstAidKit prefab!");
return;
}
Item val4 = null;
Item[] array2 = Resources.FindObjectsOfTypeAll<Item>();
foreach (Item val5 in array2)
{
if (((Object)val5).name == "Cure-All")
{
val4 = val5;
val.LogInfo((object)$"[ClassMod] Found Cure-All with ID: {val5.itemID}");
break;
}
}
if ((Object)(object)val4 == (Object)null)
{
val.LogError((object)"[ClassMod] Could not find Cure-All prefab!");
}
else if ((Object)(object)character.player != (Object)null)
{
if (character.player.HasEmptySlot(val2.itemID))
{
ItemSlot val6 = default(ItemSlot);
if (character.player.AddItem(val2.itemID, (ItemInstanceData)null, ref val6))
{
val.LogInfo((object)$"[ClassMod] Successfully gave FirstAidKit to {character.characterName} in slot {val6.itemSlotID}");
}
else
{
val.LogError((object)("[ClassMod] Failed to add FirstAidKit to " + character.characterName));
}
}
else
{
val.LogWarning((object)("[ClassMod] No empty slots available for FirstAidKit for " + character.characterName));
}
if (character.player.HasEmptySlot(val4.itemID))
{
ItemSlot val7 = default(ItemSlot);
if (character.player.AddItem(val4.itemID, (ItemInstanceData)null, ref val7))
{
val.LogInfo((object)$"[ClassMod] Successfully gave Cure-All to {character.characterName} in slot {val7.itemSlotID}");
}
else
{
val.LogError((object)("[ClassMod] Failed to add Cure-All to " + character.characterName));
}
}
else
{
val.LogWarning((object)("[ClassMod] No empty slots available for Cure-All for " + character.characterName));
}
}
else
{
val.LogError((object)("[ClassMod] Character " + character.characterName + " has no player component!"));
}
}
private static void GiveChainShooters(Character character)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
Item val2 = null;
Item[] array = Resources.FindObjectsOfTypeAll<Item>();
foreach (Item val3 in array)
{
if (((Object)val3).name == "ChainShooter")
{
val2 = val3;
val.LogInfo((object)$"[ClassMod] Found ChainShooter with ID: {val3.itemID}");
break;
}
}
if ((Object)(object)val2 == (Object)null)
{
val.LogError((object)"[ClassMod] Could not find ChainShooter prefab!");
}
else if ((Object)(object)character.player != (Object)null)
{
int num = 0;
if (character.player.HasEmptySlot(val2.itemID))
{
ItemSlot val4 = default(ItemSlot);
if (character.player.AddItem(val2.itemID, (ItemInstanceData)null, ref val4))
{
val.LogInfo((object)$"[ClassMod] Successfully gave first ChainShooter to {character.characterName} in slot {val4.itemSlotID}");
num++;
}
else
{
val.LogError((object)("[ClassMod] Failed to add first ChainShooter to " + character.characterName));
}
}
else
{
val.LogWarning((object)("[ClassMod] No empty slots available for first ChainShooter for " + character.characterName));
}
if (character.player.HasEmptySlot(val2.itemID))
{
ItemSlot val5 = default(ItemSlot);
if (character.player.AddItem(val2.itemID, (ItemInstanceData)null, ref val5))
{
val.LogInfo((object)$"[ClassMod] Successfully gave second ChainShooter to {character.characterName} in slot {val5.itemSlotID}");
num++;
}
else
{
val.LogError((object)("[ClassMod] Failed to add second ChainShooter to " + character.characterName));
}
}
else
{
val.LogWarning((object)("[ClassMod] No empty slots available for second ChainShooter for " + character.characterName));
}
val.LogInfo((object)$"[ClassMod] Total ChainShooters given to {character.characterName}: {num}/2");
}
else
{
val.LogError((object)("[ClassMod] Character " + character.characterName + " has no player component!"));
}
}
private static void GiveMushroomancerItems(Character character)
{
ManualLogSource logger = Logger.CreateLogSource("PeakClassMod");
Item val = null;
Item[] array = Resources.FindObjectsOfTypeAll<Item>();
foreach (Item val2 in array)
{
if (((Object)val2).name == "ShelfShroom")
{
val = val2;
logger.LogInfo((object)$"[ClassMod] Found ShelfShroom with ID: {val2.itemID}");
break;
}
}
if ((Object)(object)val == (Object)null)
{
logger.LogError((object)"[ClassMod] Could not find ShelfShroom prefab!");
return;
}
Item val3 = null;
Item[] array2 = Resources.FindObjectsOfTypeAll<Item>();
foreach (Item val4 in array2)
{
if (((Object)val4).name == "HealingPuffShroom")
{
val3 = val4;
logger.LogInfo((object)$"[ClassMod] Found HealingPuffShroom with ID: {val4.itemID}");
break;
}
}
if ((Object)(object)val3 == (Object)null)
{
logger.LogError((object)"[ClassMod] Could not find HealingPuffShroom prefab!");
return;
}
Item val5 = null;
Item[] array3 = Resources.FindObjectsOfTypeAll<Item>();
foreach (Item val6 in array3)
{
if (((Object)val6).name == "BounceShroom")
{
val5 = val6;
logger.LogInfo((object)$"[ClassMod] Found BounceShroom with ID: {val6.itemID}");
break;
}
}
if ((Object)(object)val5 == (Object)null)
{
logger.LogError((object)"[ClassMod] Could not find BounceShroom prefab!");
}
else if ((Object)(object)character.player != (Object)null)
{
AddItemWithRetry(val, "ShelfShroom");
AddItemWithRetry(val3, "HealingPuffShroom");
AddItemWithRetry(val5, "BounceShroom");
}
else
{
logger.LogError((object)("[ClassMod] Character " + character.characterName + " has no player component!"));
}
bool AddItemWithRetry(Item prefab, string itemName)
{
int num = 5;
ItemSlot val7 = default(ItemSlot);
ItemSlot val8 = default(ItemSlot);
for (int l = 0; l < num; l++)
{
if (character.player.HasEmptySlot(prefab.itemID))
{
if (character.player.AddItem(prefab.itemID, (ItemInstanceData)null, ref val7))
{
logger.LogInfo((object)$"[ClassMod] Successfully gave {itemName} to {character.characterName} in slot {val7.itemSlotID}");
return true;
}
logger.LogWarning((object)$"[ClassMod] Failed to add {itemName} to {character.characterName} (attempt {l + 1})");
}
else
{
if (character.player.AddItem(prefab.itemID, (ItemInstanceData)null, ref val8))
{
logger.LogInfo((object)$"[ClassMod] Successfully gave {itemName} to {character.characterName} in slot {val8.itemSlotID} (retry method, attempt {l + 1})");
return true;
}
logger.LogWarning((object)$"[ClassMod] No empty slots available for {itemName} for {character.characterName} (attempt {l + 1})");
}
if (l < num - 1)
{
Thread.Sleep(100);
}
}
logger.LogError((object)$"[ClassMod] Failed to add {itemName} to {character.characterName} after {num} attempts");
return false;
}
}
private static void GiveRogueItems(Character character)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
Item val2 = null;
Item[] array = Resources.FindObjectsOfTypeAll<Item>();
foreach (Item val3 in array)
{
if (((Object)val3).name == "RopeSpool")
{
val2 = val3;
val.LogInfo((object)$"[ClassMod] Found RopeSpool with ID: {val3.itemID}");
break;
}
}
if ((Object)(object)val2 == (Object)null)
{
val.LogError((object)"[ClassMod] Could not find RopeSpool prefab!");
}
else if ((Object)(object)character.player != (Object)null)
{
if (character.player.HasEmptySlot(val2.itemID))
{
ItemSlot val4 = default(ItemSlot);
if (character.player.AddItem(val2.itemID, (ItemInstanceData)null, ref val4))
{
val.LogInfo((object)$"[ClassMod] Successfully gave RopeSpool to {character.characterName} in slot {val4.itemSlotID}");
}
else
{
val.LogError((object)("[ClassMod] Failed to add RopeSpool to " + character.characterName));
}
}
else
{
val.LogWarning((object)("[ClassMod] No empty slots available for RopeSpool for " + character.characterName));
}
}
else
{
val.LogError((object)("[ClassMod] Character " + character.characterName + " has no player component!"));
}
}
}
[HarmonyPatch(typeof(RunManager), "StartRun")]
public class RunManager_StartRun_Curse_Patch
{
[CompilerGenerated]
private sealed class <AddEffectsDelayed>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private ManualLogSource <logger>5__1;
private PersistentPlayerData <playerData>5__2;
private int <hatIndex>5__3;
private CustomizationOption[] <hats>5__4;
private string <hatName>5__5;
private Item <ropePrefab>5__6;
private Item[] <>s__7;
private int <>s__8;
private Item <item>5__9;
private ItemSlot <slot>5__10;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AddEffectsDelayed>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<logger>5__1 = null;
<playerData>5__2 = null;
<hats>5__4 = null;
<hatName>5__5 = null;
<ropePrefab>5__6 = null;
<>s__7 = null;
<item>5__9 = null;
<slot>5__10 = null;
<>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(5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<logger>5__1 = Logger.CreateLogSource("PeakClassMod");
if ((Object)(object)Character.localCharacter != (Object)null && (Object)(object)Character.localCharacter.refs?.customization != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
<playerData>5__2 = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)Character.localCharacter).photonView.Owner) : null);
if (<playerData>5__2 != null)
{
<hatIndex>5__3 = <playerData>5__2.customizationData.currentHat;
<hats>5__4 = Singleton<Customization>.Instance?.hats;
if (<hats>5__4 != null && <hatIndex>5__3 >= 0 && <hatIndex>5__3 < <hats>5__4.Length)
{
<hatName>5__5 = ((Object)<hats>5__4[<hatIndex>5__3]).name;
if (<hatName>5__5 == "Hat_NinjaHeadband")
{
ClassManager.ActivateRogueClass();
<logger>5__1.LogInfo((object)"[ClassMod] Rogue class activated!");
<ropePrefab>5__6 = null;
<>s__7 = Resources.FindObjectsOfTypeAll<Item>();
for (<>s__8 = 0; <>s__8 < <>s__7.Length; <>s__8++)
{
<item>5__9 = <>s__7[<>s__8];
if (((Object)<item>5__9).name == "RopeSpool")
{
<ropePrefab>5__6 = <item>5__9;
<logger>5__1.LogInfo((object)$"[ClassMod] Found RopeSpool with ID: {<item>5__9.itemID}");
break;
}
<item>5__9 = null;
}
<>s__7 = null;
if ((Object)(object)<ropePrefab>5__6 != (Object)null && (Object)(object)Character.localCharacter.player != (Object)null)
{
if (Character.localCharacter.player.HasEmptySlot(<ropePrefab>5__6.itemID))
{
if (Character.localCharacter.player.AddItem(<ropePrefab>5__6.itemID, (ItemInstanceData)null, ref <slot>5__10))
{
<logger>5__1.LogInfo((object)"[ClassMod] Rogue kezdő item: RopeSpool hozzáadva!");
}
else
{
<logger>5__1.LogWarning((object)"[ClassMod] Nem sikerült RopeSpool-t adni a Rogue-nak!");
}
<slot>5__10 = null;
}
else
{
<logger>5__1.LogWarning((object)"[ClassMod] Nincs üres slot a RopeSpool számára!");
}
}
else
{
if ((Object)(object)<ropePrefab>5__6 == (Object)null)
{
<logger>5__1.LogError((object)"[ClassMod] RopeSpool prefab nem található!");
}
if ((Object)(object)Character.localCharacter.player == (Object)null)
{
<logger>5__1.LogError((object)"[ClassMod] Character.player komponens nem található!");
}
}
<ropePrefab>5__6 = null;
}
else if (<hatName>5__5 == "Hat_Propeller")
{
ClassManager.ActivateGreatEpeeClass();
<logger>5__1.LogInfo((object)"[ClassMod] Great Épée class activated!");
}
else if (<hatName>5__5 == "Hat_Medic" || <hatName>5__5 == "MedicHelmet")
{
ClassManager.ActivateMedicClass();
<logger>5__1.LogInfo((object)"[ClassMod] Medic class activated!");
if ((Object)(object)Character.localCharacter.refs?.afflictions != (Object)null)
{
Character.localCharacter.refs.afflictions.AddStatus((STATUSTYPE)5, 0.12f, false);
<logger>5__1.LogInfo((object)"[ClassMod] Medic curse effect (12%) added!");
}
}
<hatName>5__5 = null;
}
<hats>5__4 = null;
}
<playerData>5__2 = null;
}
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 void Postfix()
{
((MonoBehaviour)RunManager.Instance).StartCoroutine(AddEffectsDelayed());
}
[IteratorStateMachine(typeof(<AddEffectsDelayed>d__1))]
private static IEnumerator AddEffectsDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AddEffectsDelayed>d__1(0);
}
}
[HarmonyPatch(typeof(Affliction_ClearAllStatus), "OnApplied")]
public class Affliction_ClearAllStatus_OnApplied_Patch
{
private static void Prefix(Affliction_ClearAllStatus __instance)
{
if (!((Object)(object)((Affliction)__instance).character != (Object)null))
{
return;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)((Affliction)__instance).character).photonView.Owner) : null);
if (val == null)
{
return;
}
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Medic" || name == "MedicHelmet")
{
__instance.excludeCurse = true;
ManualLogSource val2 = Logger.CreateLogSource("PeakClassMod");
val2.LogInfo((object)("[ClassMod] Prevented Affliction_ClearAllStatus from removing curse effect for Medic class character: " + ((Affliction)__instance).character.characterName));
}
}
}
}
[HarmonyPatch(typeof(Affliction_Chaos), "OnApplied")]
public class Affliction_Chaos_OnApplied_Patch
{
private static void Prefix(Affliction_Chaos __instance)
{
if (!((Object)(object)((Affliction)__instance).character != (Object)null))
{
return;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)((Affliction)__instance).character).photonView.Owner) : null);
if (val == null)
{
return;
}
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Medic" || name == "MedicHelmet")
{
ManualLogSource val2 = Logger.CreateLogSource("PeakClassMod");
val2.LogInfo((object)("[ClassMod] Affliction_Chaos detected for Medic class character: " + ((Affliction)__instance).character.characterName + ", will prevent curse removal"));
}
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "ClearAllStatus")]
public class CharacterAfflictions_ClearAllStatus_Patch
{
private static void Prefix(CharacterAfflictions __instance, bool excludeCurse, ref bool __state)
{
__state = excludeCurse;
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
val.LogInfo((object)$"[ClassMod] ClearAllStatus called with excludeCurse: {excludeCurse}");
if (!((Object)(object)__instance.character != (Object)null))
{
return;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val2 = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.character).photonView.Owner) : null);
if (val2 == null)
{
return;
}
int currentHat = val2.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Medic" || name == "MedicHelmet")
{
excludeCurse = true;
val.LogInfo((object)("[ClassMod] ClearAllStatus called for Medic class character: " + __instance.character.characterName + ", forcing excludeCurse = true"));
}
}
}
}
[HarmonyPatch(typeof(Item), "StartUsePrimary")]
public class Item_StartUsePrimary_Patch
{
private static bool Prefix(Item __instance)
{
if ((Object)(object)__instance.holderCharacter != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.holderCharacter).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab" && (Object)(object)((Component)__instance).GetComponent<Action_RestoreHunger>() != (Object)null)
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Item), "StartUseSecondary")]
public class Item_StartUseSecondary_Patch
{
private static bool Prefix(Item __instance)
{
if ((Object)(object)__instance.holderCharacter != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.holderCharacter).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab" && (Object)(object)((Component)__instance).GetComponent<Action_RestoreHunger>() != (Object)null)
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Character), "AddExtraStamina")]
public class Character_AddExtraStamina_Patch
{
private static bool Prefix(Character __instance, float add)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
return false;
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Affliction_InfiniteStamina), "OnApplied")]
public class Affliction_InfiniteStamina_OnApplied_Patch
{
private static bool Prefix(Affliction_InfiniteStamina __instance)
{
if ((Object)(object)((Affliction)__instance).character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)((Affliction)__instance).character).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Affliction_InfiniteStamina), "UpdateEffect")]
public class Affliction_InfiniteStamina_UpdateEffect_Patch
{
private static bool Prefix(Affliction_InfiniteStamina __instance)
{
if ((Object)(object)((Affliction)__instance).character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)((Affliction)__instance).character).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Affliction_AddBonusStamina), "OnApplied")]
public class Affliction_AddBonusStamina_OnApplied_Patch
{
private static bool Prefix(Affliction_AddBonusStamina __instance)
{
if ((Object)(object)((Affliction)__instance).character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)((Affliction)__instance).character).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Action_GiveExtraStamina), "RunAction")]
public class Action_GiveExtraStamina_RunAction_Patch
{
private static bool Prefix(Action_GiveExtraStamina __instance)
{
object? obj = typeof(ItemActionBase).GetField("item", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
Item val = (Item)((obj is Item) ? obj : null);
Character val2 = ((val != null) ? val.holderCharacter : null);
if ((Object)(object)val2 != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val3 = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)val2).photonView.Owner) : null);
if (val3 != null)
{
int currentHat = val3.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Affliction_FasterBoi), "OnApplied")]
public class Affliction_FasterBoi_OnApplied_Patch
{
private static bool Prefix(Affliction_FasterBoi __instance)
{
if ((Object)(object)((Affliction)__instance).character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)((Affliction)__instance).character).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Action_ApplyInfiniteStamina), "RunAction")]
public class Action_ApplyInfiniteStamina_RunAction_Patch
{
private static bool Prefix(Action_ApplyInfiniteStamina __instance)
{
object? obj = typeof(ItemActionBase).GetField("item", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
Item val = (Item)((obj is Item) ? obj : null);
Character val2 = ((val != null) ? val.holderCharacter : null);
if ((Object)(object)val2 != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val3 = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)val2).photonView.Owner) : null);
if (val3 != null)
{
int currentHat = val3.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab")
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Action_ApplyMassAffliction), "TryAddAfflictionToLocalCharacter")]
public class Action_ApplyMassAffliction_TryAddAfflictionToLocalCharacter_Patch
{
private static bool Prefix(Action_ApplyMassAffliction __instance)
{
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Invalid comparison between Unknown and I4
if ((Object)(object)Character.localCharacter != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)Character.localCharacter).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Crab" && ((Action_ApplyAffliction)__instance).affliction != null && (int)((Action_ApplyAffliction)__instance).affliction.GetAfflictionType() == 1)
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Affliction_PoisonOverTime), "OnApplied")]
public class Affliction_PoisonOverTime_OnApplied_Patch
{
private static bool Prefix(Affliction_PoisonOverTime __instance)
{
if ((Object)(object)((Affliction)__instance).character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)((Affliction)__instance).character).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Mushroom")
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
public class CharacterAfflictions_AddStatus_Poison_Patch
{
private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
if ((int)statusType == 3 && (Object)(object)__instance.character != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)__instance.character).photonView.Owner) : null);
if (val != null)
{
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array != null && currentHat >= 0 && currentHat < array.Length)
{
string name = ((Object)array[currentHat]).name;
if (name == "Hat_Mushroom")
{
amount = 0f;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(Character), "UseStamina")]
public class Character_UseStamina_Mushroomancer_Patch
{
private static void Postfix(Character __instance, float usage, bool useBonusStamina, bool __result)
{
if (__instance.data.currentStamina <= 0f || (!__result && __instance.data.isClimbingAnything))
{
ClassManager.TryActivateStaminaZeroMechanic(__instance);
}
}
}
[HarmonyPatch(typeof(Character), "OutOfStamina")]
public class Character_OutOfStamina_Mushroomancer_Patch
{
private static void Postfix(Character __instance, bool __result)
{
if (__result && __instance.data.isClimbingAnything)
{
ClassManager.TryActivateStaminaZeroMechanic(__instance);
}
}
}
public static class ClassManager
{
[CompilerGenerated]
private sealed class <GreatEpeePermanentEffects>d__20 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Character character;
private ManualLogSource <logger>5__1;
private bool <hasFasterBoi>5__2;
private List<Affliction>.Enumerator <>s__3;
private Affliction <aff>5__4;
private Affliction_FasterBoi <fasterBoi>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GreatEpeePermanentEffects>d__20(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<logger>5__1 = null;
<>s__3 = default(List<Affliction>.Enumerator);
<aff>5__4 = null;
<fasterBoi>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Expected O, but got Unknown
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<logger>5__1 = Logger.CreateLogSource("PeakClassMod");
break;
case 1:
<>1__state = -1;
break;
}
if (IsGreatEpeeActive() && (Object)(object)character != (Object)null && character.IsLocal)
{
<hasFasterBoi>5__2 = false;
<>s__3 = character.refs.afflictions.afflictionList.GetEnumerator();
try
{
while (<>s__3.MoveNext())
{
<aff>5__4 = <>s__3.Current;
if (((object)<aff>5__4).GetType().Name == "Affliction_FasterBoi")
{
<hasFasterBoi>5__2 = true;
break;
}
<aff>5__4 = null;
}
}
finally
{
((IDisposable)<>s__3).Dispose();
}
<>s__3 = default(List<Affliction>.Enumerator);
if (!<hasFasterBoi>5__2)
{
<fasterBoi>5__5 = new Affliction_FasterBoi();
((Affliction)<fasterBoi>5__5).totalTime = 99999f;
character.refs.afflictions.AddAffliction((Affliction)(object)<fasterBoi>5__5, false);
<logger>5__1.LogInfo((object)"[ClassMod] Great Épée: Permanent energy drink effect applied!");
<fasterBoi>5__5 = null;
}
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return 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 <GreatEpeeStaminaRoutine>d__21 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Character character;
private ManualLogSource <logger>5__1;
private float <waitTime>5__2;
private float <duration>5__3;
private float <elapsed>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GreatEpeeStaminaRoutine>d__21(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<logger>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<logger>5__1 = Logger.CreateLogSource("PeakClassMod");
break;
case 1:
<>1__state = -1;
<duration>5__3 = 3f;
<elapsed>5__4 = 0f;
character.refs.afflictions.AddStatus((STATUSTYPE)6, 1f, false);
<logger>5__1.LogInfo((object)"[ClassMod] Great Épée: 100% Sleep (Drowsy) effect applied!");
goto IL_0115;
case 2:
<>1__state = -1;
goto IL_0115;
case 3:
{
<>1__state = -1;
break;
}
IL_0115:
if (<elapsed>5__4 < <duration>5__3)
{
<elapsed>5__4 += Time.deltaTime;
<>2__current = null;
<>1__state = 2;
return true;
}
<logger>5__1.LogInfo((object)"[ClassMod] Great Épée: 3 mp Drowsy effect completed!");
<>2__current = null;
<>1__state = 3;
return true;
}
if (IsGreatEpeeActive() && (Object)(object)character != (Object)null && character.IsLocal)
{
<waitTime>5__2 = Random.Range(50f, 190f);
<logger>5__1.LogInfo((object)$"[ClassMod] Great Épée: Következő stamina feltöltés {<waitTime>5__2} mp múlva");
<>2__current = (object)new WaitForSeconds(<waitTime>5__2);
<>1__state = 1;
return 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 <SpawnRandomMushroomDelayed>d__3 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Character character;
private ManualLogSource <logger>5__1;
private string[] <mushroomTypes>5__2;
private string <selectedMushroom>5__3;
private Item <mushroomPrefab>5__4;
private Item[] <>s__5;
private int <>s__6;
private Item <item>5__7;
private Vector3 <spawnPosition>5__8;
private Item <spawnedItem>5__9;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnRandomMushroomDelayed>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<logger>5__1 = null;
<mushroomTypes>5__2 = null;
<selectedMushroom>5__3 = null;
<mushroomPrefab>5__4 = null;
<>s__5 = null;
<item>5__7 = null;
<spawnedItem>5__9 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
//IL_01db: Unknown result type (might be due to invalid IL or missing references)
//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0491: Unknown result type (might be due to invalid IL or missing references)
//IL_0496: Unknown result type (might be due to invalid IL or missing references)
//IL_043e: Unknown result type (might be due to invalid IL or missing references)
//IL_0469: Unknown result type (might be due to invalid IL or missing references)
//IL_0257: Unknown result type (might be due to invalid IL or missing references)
//IL_0267: Unknown result type (might be due to invalid IL or missing references)
//IL_0271: Unknown result type (might be due to invalid IL or missing references)
//IL_0276: Unknown result type (might be due to invalid IL or missing references)
//IL_027b: Unknown result type (might be due to invalid IL or missing references)
//IL_0285: Unknown result type (might be due to invalid IL or missing references)
//IL_028a: Unknown result type (might be due to invalid IL or missing references)
//IL_028f: Unknown result type (might be due to invalid IL or missing references)
//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
//IL_0510: Unknown result type (might be due to invalid IL or missing references)
//IL_032a: Unknown result type (might be due to invalid IL or missing references)
//IL_032f: Unknown result type (might be due to invalid IL or missing references)
//IL_0339: Unknown result type (might be due to invalid IL or missing references)
//IL_033e: Unknown result type (might be due to invalid IL or missing references)
//IL_0343: Unknown result type (might be due to invalid IL or missing references)
//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0301: Unknown result type (might be due to invalid IL or missing references)
//IL_0306: Unknown result type (might be due to invalid IL or missing references)
//IL_0310: Unknown result type (might be due to invalid IL or missing references)
//IL_0315: Unknown result type (might be due to invalid IL or missing references)
//IL_031a: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<logger>5__1 = Logger.CreateLogSource("PeakClassMod");
<mushroomTypes>5__2 = new string[3] { "ShelfShroom", "HealingPuffShroom", "BounceShroom" };
<selectedMushroom>5__3 = <mushroomTypes>5__2[Random.Range(0, <mushroomTypes>5__2.Length)];
<mushroomPrefab>5__4 = null;
<>s__5 = Resources.FindObjectsOfTypeAll<Item>();
for (<>s__6 = 0; <>s__6 < <>s__5.Length; <>s__6++)
{
<item>5__7 = <>s__5[<>s__6];
if (((Object)<item>5__7).name == <selectedMushroom>5__3)
{
<mushroomPrefab>5__4 = <item>5__7;
<logger>5__1.LogInfo((object)$"[ClassMod] Found {<selectedMushroom>5__3} with ID: {<item>5__7.itemID}");
break;
}
<item>5__7 = null;
}
<>s__5 = null;
if ((Object)(object)<mushroomPrefab>5__4 == (Object)null)
{
<logger>5__1.LogError((object)("[ClassMod] Could not find " + <selectedMushroom>5__3 + " prefab!"));
return false;
}
if ((Object)(object)character != (Object)null && (Object)(object)((Component)character).transform != (Object)null)
{
if (character.data.isClimbing)
{
<spawnPosition>5__8 = character.data.climbPos + character.data.climbNormal * 0.4f + Vector3.down * 0.5f;
}
else if (character.data.isRopeClimbing && (Object)(object)character.data.heldRope != (Object)null)
{
<spawnPosition>5__8 = character.data.heldRope.climbingAPI.GetPosition(character.data.ropePercent) + character.data.ropeClimbWorldNormal * 0.5f + Vector3.down * 0.5f;
}
else if (character.data.isVineClimbing && (Object)(object)character.data.heldVine != (Object)null)
{
<spawnPosition>5__8 = character.data.heldVine.GetPosition(character.data.vinePercent) + Vector3.down * 1f + Vector3.down * 0.5f;
}
else
{
<spawnPosition>5__8 = character.Center + Vector3.down * 0.5f;
}
<logger>5__1.LogInfo((object)("[ClassMod] Spawn position calculation for " + character.characterName + ":"));
<logger>5__1.LogInfo((object)$"[ClassMod] - isClimbing: {character.data.isClimbing}");
<logger>5__1.LogInfo((object)$"[ClassMod] - isRopeClimbing: {character.data.isRopeClimbing}");
<logger>5__1.LogInfo((object)$"[ClassMod] - isVineClimbing: {character.data.isVineClimbing}");
<logger>5__1.LogInfo((object)$"[ClassMod] - Final spawn position: {<spawnPosition>5__8}");
if (character.data.isClimbing)
{
<logger>5__1.LogInfo((object)$"[ClassMod] - ClimbPos: {character.data.climbPos}");
<logger>5__1.LogInfo((object)$"[ClassMod] - ClimbNormal: {character.data.climbNormal}");
}
<spawnedItem>5__9 = PhotonNetwork.InstantiateItemRoom(((Object)((Component)<mushroomPrefab>5__4).gameObject).name, <spawnPosition>5__8, Quaternion.identity).GetComponent<Item>();
if ((Object)(object)<spawnedItem>5__9 != (Object)null)
{
((Component)<spawnedItem>5__9).GetComponent<PhotonView>().RPC("SetKinematicRPC", (RpcTarget)3, new object[3]
{
true,
<spawnPosition>5__8,
Quaternion.identity
});
<logger>5__1.LogInfo((object)$"[ClassMod] Successfully spawned {<selectedMushroom>5__3} at position {<spawnPosition>5__8} for {character.characterName} due to stamina reaching 0");
}
else
{
<logger>5__1.LogError((object)("[ClassMod] Failed to spawn " + <selectedMushroom>5__3 + " for " + character.characterName));
}
<spawnedItem>5__9 = null;
}
else
{
ManualLogSource obj = <logger>5__1;
Character obj2 = character;
obj.LogError((object)("[ClassMod] Character " + (((obj2 != null) ? obj2.characterName : null) ?? "NULL") + " has no transform component!"));
}
<logger>5__1.LogInfo((object)"[ClassMod] Mushroom spawn completed for Mushroomancer");
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 Dictionary<Player, float> lastStaminaZeroTime = new Dictionary<Player, float>();
private const float COOLDOWN_DURATION = 5f;
private static Dictionary<Character, Coroutine> greatEpeeStaminaCoroutines = new Dictionary<Character, Coroutine>();
public static bool TryActivateStaminaZeroMechanic(Character character)
{
if (!((Object)(object)character == (Object)null))
{
PhotonView photonView = ((MonoBehaviourPun)character).photonView;
if (((photonView != null) ? photonView.Owner : null) != null)
{
Player owner = ((MonoBehaviourPun)character).photonView.Owner;
float time = Time.time;
if (lastStaminaZeroTime.ContainsKey(owner) && time - lastStaminaZeroTime[owner] < 5f)
{
return false;
}
if (!IsMushroomancerClass(character))
{
return false;
}
if (character.data.currentStamina > 0f)
{
return false;
}
lastStaminaZeroTime[owner] = time;
if (character.IsLocal)
{
character.refs.afflictions.AddStatus((STATUSTYPE)5, 0.02f, false);
}
if (PhotonNetwork.IsMasterClient)
{
((MonoBehaviour)character).StartCoroutine(SpawnRandomMushroomDelayed(character));
}
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
val.LogInfo((object)("[ClassMod] Stamina zero mechanic activated for player: " + owner.NickName));
return true;
}
}
return false;
}
[IteratorStateMachine(typeof(<SpawnRandomMushroomDelayed>d__3))]
public static IEnumerator SpawnRandomMushroomDelayed(Character character)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnRandomMushroomDelayed>d__3(0)
{
character = character
};
}
public static void ActivateScoutClass()
{
PeakClassModPlugin.scoutActive = true;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.currentClass = "Scout";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
}
public static void ActivateMedicClass()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = true;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.currentClass = "Medic";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
}
public static void ActivateTechPriestClass()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = true;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.currentClass = "Tech-Priest";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
}
public static void ActivateMushroomancerClass()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = true;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.currentClass = "Mushroomancer";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
}
public static void ActivateGreatEpeeClass()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = true;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.currentClass = "GreatEpee";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
if ((Object)(object)Character.localCharacter != (Object)null)
{
((MonoBehaviour)Character.localCharacter).StartCoroutine(GreatEpeePermanentEffects(Character.localCharacter));
if (greatEpeeStaminaCoroutines.ContainsKey(Character.localCharacter))
{
((MonoBehaviour)Character.localCharacter).StopCoroutine(greatEpeeStaminaCoroutines[Character.localCharacter]);
greatEpeeStaminaCoroutines.Remove(Character.localCharacter);
}
Coroutine value = ((MonoBehaviour)Character.localCharacter).StartCoroutine(GreatEpeeStaminaRoutine(Character.localCharacter));
greatEpeeStaminaCoroutines[Character.localCharacter] = value;
}
}
public static void ActivateRogueClass()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = true;
PeakClassModPlugin.currentClass = "Rogue";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 2;
}
}
public static void DeactivateAllClasses()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.currentClass = "None";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
if ((Object)(object)Character.localCharacter != (Object)null && greatEpeeStaminaCoroutines.ContainsKey(Character.localCharacter))
{
((MonoBehaviour)Character.localCharacter).StopCoroutine(greatEpeeStaminaCoroutines[Character.localCharacter]);
greatEpeeStaminaCoroutines.Remove(Character.localCharacter);
}
}
public static bool IsScoutActive()
{
return PeakClassModPlugin.scoutActive;
}
public static bool IsMedicActive()
{
return PeakClassModPlugin.medicActive;
}
public static bool IsTechPriestActive()
{
return PeakClassModPlugin.techPriestActive;
}
public static bool IsMushroomancerActive()
{
return PeakClassModPlugin.mushroomancerActive;
}
public static bool IsGreatEpeeActive()
{
return PeakClassModPlugin.greatEpeeActive;
}
public static bool IsRogueActive()
{
return PeakClassModPlugin.rogueActive;
}
public static string GetCurrentClass()
{
return PeakClassModPlugin.currentClass;
}
private static bool IsMushroomancerClass(Character character)
{
if ((Object)(object)character == (Object)null || (Object)(object)((MonoBehaviourPun)character).photonView == (Object)null || ((MonoBehaviourPun)character).photonView.Owner == null)
{
return false;
}
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
PersistentPlayerData val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)character).photonView.Owner) : null);
if (val == null)
{
return false;
}
int currentHat = val.customizationData.currentHat;
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
if (array == null || currentHat < 0 || currentHat >= array.Length)
{
return false;
}
string name = ((Object)array[currentHat]).name;
return name == "Hat_Mushroom";
}
[IteratorStateMachine(typeof(<GreatEpeePermanentEffects>d__20))]
private static IEnumerator GreatEpeePermanentEffects(Character character)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GreatEpeePermanentEffects>d__20(0)
{
character = character
};
}
[IteratorStateMachine(typeof(<GreatEpeeStaminaRoutine>d__21))]
private static IEnumerator GreatEpeeStaminaRoutine(Character character)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GreatEpeeStaminaRoutine>d__21(0)
{
character = character
};
}
public static void ActivateEddieClass()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.eddieActive = true;
PeakClassModPlugin.currentClass = "Eddie";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
}
public static bool IsEddieActive()
{
return PeakClassModPlugin.eddieActive;
}
public static void ActivateBillClass()
{
PeakClassModPlugin.scoutActive = false;
PeakClassModPlugin.medicActive = false;
PeakClassModPlugin.techPriestActive = false;
PeakClassModPlugin.mushroomancerActive = false;
PeakClassModPlugin.greatEpeeActive = false;
PeakClassModPlugin.rogueActive = false;
PeakClassModPlugin.eddieActive = false;
PeakClassModPlugin.billActive = true;
PeakClassModPlugin.currentClass = "Bill";
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.data.jumpsRemaining = 1;
}
}
public static bool IsBillActive()
{
return PeakClassModPlugin.billActive;
}
}
[HarmonyPatch(typeof(CharacterMovement), "EvaluateGroundChecks")]
public class CharacterMovement_EvaluateGroundChecks_Rogue_Patch
{
private static void Postfix(CharacterMovement __instance)
{
Character component = ((Component)__instance).GetComponent<Character>();
if (!((Object)(object)component == (Object)null) && component.IsLocal)
{
if (ClassManager.IsRogueActive())
{
component.data.jumpsRemaining = 2;
}
else
{
component.data.jumpsRemaining = 1;
}
}
}
}
[HarmonyPatch(typeof(CharacterMovement), "TryToJump")]
public class CharacterMovement_TryToJump_Rogue_Patch
{
private static bool Prefix(CharacterMovement __instance)
{
Character component = ((Component)__instance).GetComponent<Character>();
if ((Object)(object)component == (Object)null || !component.IsLocal)
{
return true;
}
if (ClassManager.IsRogueActive() && component.data.jumpsRemaining > 0 && component.data.currentStamina > 0.005f && !component.data.fullyPassedOut && !component.data.isClimbing && !component.data.isRopeClimbing && !component.data.isVineClimbing && (Object)(object)component.data.currentClimbHandle == (Object)null)
{
CharacterData data = component.data;
data.jumpsRemaining--;
component.data.isCrouching = false;
component.data.chargingJump = true;
component.refs.view.RPC("JumpRpc", (RpcTarget)0, new object[1] { false });
return false;
}
if (component.data.jumpsRemaining > 0 && component.data.isGrounded && !component.data.fullyPassedOut && !component.data.isClimbing && !component.data.isRopeClimbing && !component.data.isVineClimbing && (Object)(object)component.data.currentClimbHandle == (Object)null)
{
return true;
}
return false;
}
}
[HarmonyPatch(typeof(Character), "UseStamina")]
public class Character_UseStamina_RogueJumpCost_Patch
{
private static void Prefix(Character __instance, ref float usage, bool useBonusStamina)
{
if (__instance.IsLocal && ClassManager.IsRogueActive())
{
usage *= 2.5f;
}
}
}
[HarmonyPatch(typeof(CharacterCustomization), "SetCharacterHat")]
public class CharacterCustomization_SetCharacterHat_Eddie_Patch
{
private static void Postfix(int index)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
string text = "Unknown";
if (array != null && index >= 0 && index < array.Length)
{
CustomizationOption obj = array[index];
text = ((obj != null) ? ((Object)obj).name : null) ?? "NULL";
}
if (text == "Hat_Beret")
{
ClassManager.ActivateEddieClass();
val.LogInfo((object)"[ClassMod] Eddie class activated!");
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
public class CharacterAfflictions_AddStatus_Eddie_Patch
{
private static void Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Invalid comparison between Unknown and I4
Character character = __instance.character;
if (!((Object)(object)character == (Object)null) && character.IsLocal && ClassManager.IsEddieActive() && (int)statusType == 1)
{
amount *= 1.5f;
}
}
}
[HarmonyPatch(typeof(BarAffliction), "ChangeAffliction")]
public class BarAffliction_ChangeAffliction_Eddie_Patch
{
private static void Postfix(BarAffliction __instance, StaminaBar bar)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Invalid comparison between Unknown and I4
if (ClassManager.IsEddieActive() && (int)__instance.afflictionType == 7)
{
__instance.size *= 0.5f;
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "get_statusSum")]
public class CharacterAfflictions_StatusSum_Eddie_Patch
{
private static void Postfix(CharacterAfflictions __instance, ref float __result)
{
if (ClassManager.IsEddieActive())
{
float num = 0f;
if (__instance.currentStatuses != null && __instance.currentStatuses.Length > 7)
{
num = __instance.currentStatuses[7];
}
__result = __result - num + num * 0.5f;
}
}
}
[HarmonyPatch(typeof(CharacterCustomization), "SetCharacterHat")]
public class CharacterCustomization_SetCharacterHat_Bill_Patch
{
private static void Postfix(int index)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
string text = "Unknown";
if (array != null && index >= 0 && index < array.Length)
{
CustomizationOption obj = array[index];
text = ((obj != null) ? ((Object)obj).name : null) ?? "NULL";
}
if (text == "Hat_Bandana")
{
ClassManager.ActivateBillClass();
val.LogInfo((object)"[ClassMod] Bill class activated!");
}
}
}
[HarmonyPatch(typeof(RunManager), "StartRun")]
public class RunManager_StartRun_Bill_Patch
{
[CompilerGenerated]
private sealed class <AddBillCurseDelayed>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private PersistentPlayerData <playerData>5__1;
private int <hatIndex>5__2;
private CustomizationOption[] <hats>5__3;
private string <hatName>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AddBillCurseDelayed>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<playerData>5__1 = null;
<hats>5__3 = null;
<hatName>5__4 = null;
<>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(5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)Character.localCharacter != (Object)null && (Object)(object)Character.localCharacter.refs?.afflictions != (Object)null)
{
PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
<playerData>5__1 = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)Character.localCharacter).photonView.Owner) : null);
if (<playerData>5__1 != null)
{
<hatIndex>5__2 = <playerData>5__1.customizationData.currentHat;
<hats>5__3 = Singleton<Customization>.Instance?.hats;
if (<hats>5__3 != null && <hatIndex>5__2 >= 0 && <hatIndex>5__2 < <hats>5__3.Length)
{
<hatName>5__4 = ((Object)<hats>5__3[<hatIndex>5__2]).name;
if (<hatName>5__4 == "Hat_Bandana")
{
Character.localCharacter.refs.afflictions.AddStatus((STATUSTYPE)5, 0.35f, false);
}
<hatName>5__4 = null;
}
<hats>5__3 = null;
}
<playerData>5__1 = null;
}
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 void Postfix()
{
((MonoBehaviour)RunManager.Instance).StartCoroutine(AddBillCurseDelayed());
}
[IteratorStateMachine(typeof(<AddBillCurseDelayed>d__1))]
private static IEnumerator AddBillCurseDelayed()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AddBillCurseDelayed>d__1(0);
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
public class CharacterAfflictions_AddStatus_Bill_Patch
{
private static void Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount, bool fromRPC)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Invalid comparison between Unknown and I4
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
Character character = __instance.character;
if (!((Object)(object)character == (Object)null) && character.IsLocal && ClassManager.IsBillActive())
{
if ((int)statusType == 7)
{
amount *= 2f;
}
else if ((int)statusType == 1)
{
amount *= 2f;
}
}
}
}
[HarmonyPatch(typeof(BarAffliction), "ChangeAffliction")]
public class BarAffliction_ChangeAffliction_Bill_Patch
{
private static void Postfix(BarAffliction __instance, StaminaBar bar)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Invalid comparison between Unknown and I4
if (ClassManager.IsBillActive() && (int)__instance.afflictionType == 7)
{
__instance.size *= 2f;
}
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "get_statusSum")]
public class CharacterAfflictions_StatusSum_Bill_Patch
{
private static void Postfix(CharacterAfflictions __instance, ref float __result)
{
if (ClassManager.IsBillActive())
{
float num = 0f;
if (__instance.currentStatuses != null && __instance.currentStatuses.Length > 7)
{
num = __instance.currentStatuses[7];
}
__result = __result - num + num * 2f;
}
}
}
[HarmonyPatch(typeof(CharacterMovement), "Update")]
public class CharacterMovement_Update_MedicHeal_Patch
{
[CompilerGenerated]
private sealed class <MedicHealAllPlayers>d__2 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Character medicCharacter;
private ManualLogSource <logger>5__1;
private int <remainingHeals>5__2;
private float <currentInjury>5__3;
private float <healAmount>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MedicHealAllPlayers>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<logger>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<logger>5__1 = Logger.CreateLogSource("PeakClassMod");
if (!medicHealUses.ContainsKey(((MonoBehaviourPun)medicCharacter).photonView.Owner))
{
medicHealUses[((MonoBehaviourPun)medicCharacter).photonView.Owner] = 10;
}
if (medicHealUses[((MonoBehaviourPun)medicCharacter).photonView.Owner] <= 0)
{
<logger>5__1.LogInfo((object)"[ClassMod] Medic class has no more heals remaining!");
return false;
}
medicHealUses[((MonoBehaviourPun)medicCharacter).photonView.Owner]--;
<remainingHeals>5__2 = medicHealUses[((MonoBehaviourPun)medicCharacter).photonView.Owner];
<logger>5__1.LogInfo((object)$"[ClassMod] Medic class using heal! Remaining heals: {<remainingHeals>5__2}");
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)medicCharacter.refs?.afflictions != (Object)null)
{
<currentInjury>5__3 = medicCharacter.refs.afflictions.GetCurrentStatus((STATUSTYPE)0);
if (<currentInjury>5__3 > 0f)
{
<healAmount>5__4 = Math.Min(0.1f, <currentInjury>5__3);
medicCharacter.refs.afflictions.SubtractStatus((STATUSTYPE)0, <healAmount>5__4, false);
<logger>5__1.LogInfo((object)$"[ClassMod] Healed {medicCharacter.characterName} for {<healAmount>5__4} Injury. New Injury: {medicCharacter.refs.afflictions.GetCurrentStatus((STATUSTYPE)0)}");
}
else
{
<logger>5__1.LogInfo((object)("[ClassMod] " + medicCharacter.characterName + " has no Injury to heal"));
}
}
else
{
ManualLogSource obj = <logger>5__1;
Character obj2 = medicCharacter;
obj.LogWarning((object)("[ClassMod] Medic character " + (((obj2 != null) ? obj2.characterName : null) ?? "NULL") + " has no afflictions component"));
}
((MonoBehaviourPun)medicCharacter).photonView.RPC("ShowMedicHealEffectRPC", (RpcTarget)0, new object[1] { <remainingHeals>5__2 });
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 Dictionary<Player, int> medicHealUses = new Dictionary<Player, int>();
private static void Postfix(CharacterMovement __instance)
{
Character component = ((Component)__instance).GetComponent<Character>();
if (!((Object)(object)component == (Object)null) && component.IsLocal && ClassManager.IsMedicActive() && (Object)(object)component.input != (Object)null && Input.GetKeyDown((KeyCode)104))
{
((MonoBehaviour)component).StartCoroutine(MedicHealAllPlayers(component));
}
}
[IteratorStateMachine(typeof(<MedicHealAllPlayers>d__2))]
private static IEnumerator MedicHealAllPlayers(Character medicCharacter)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MedicHealAllPlayers>d__2(0)
{
medicCharacter = medicCharacter
};
}
}
[HarmonyPatch(typeof(Character), "ShowMedicHealEffectRPC")]
public class Character_ShowMedicHealEffectRPC_Patch
{
private static void Postfix(Character __instance, int remainingHeals)
{
if (__instance.IsLocal)
{
ManualLogSource val = Logger.CreateLogSource("PeakClassMod");
val.LogInfo((object)$"[ClassMod] Medic heal effect displayed! Remaining heals: {remainingHeals}");
}
}
}
