using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using ClassModF;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.Afflictions;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
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: AssemblyCompany("ClassMod-F")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("ClassMod-F")]
[assembly: AssemblyTitle("ClassMod-F")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
public enum PlayerClass
{
Normal,
Scout,
Herbalist,
Forager,
Ranger,
Tinkerer
}
public static class ClassManager
{
public static Dictionary<int, float> CachedAfflictionMultipliers = new Dictionary<int, float>();
public static PlayerClass CurrentClass { get; private set; } = PlayerClass.Normal;
public static void Update()
{
if (Input.GetKeyDown((KeyCode)276))
{
SetClass(PreviousClass(CurrentClass));
}
else if (Input.GetKeyDown((KeyCode)275))
{
SetClass(NextClass(CurrentClass));
}
}
public static void SetClass(PlayerClass newClass)
{
CurrentClass = newClass;
CachedAfflictionMultipliers = ClassModifiers.GetAllAfflictionMultipliers(CurrentClass);
ClassAbilities.AssignAbility(newClass);
}
private static PlayerClass PreviousClass(PlayerClass cls)
{
int num = (int)(cls - 1);
if (num < 0)
{
num = Enum.GetValues(typeof(PlayerClass)).Length - 1;
}
return (PlayerClass)num;
}
private static PlayerClass NextClass(PlayerClass cls)
{
int num = (int)(cls + 1);
if (num >= Enum.GetValues(typeof(PlayerClass)).Length)
{
num = 0;
}
return (PlayerClass)num;
}
}
[HarmonyPatch]
public static class ClassPatches
{
[HarmonyPatch(typeof(Character), "UseStamina", new Type[]
{
typeof(float),
typeof(bool)
})]
[HarmonyPrefix]
private static void UseStamina_Prefix(ref float __0, bool __1)
{
try
{
float staminaMultiplier = ClassModifiers.GetStaminaMultiplier(ClassManager.CurrentClass);
__0 *= staminaMultiplier;
}
catch (Exception)
{
}
}
[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
[HarmonyPostfix]
private static void UpdateWeight_Postfix(CharacterAfflictions __instance)
{
try
{
float currentStatus = __instance.GetCurrentStatus((STATUSTYPE)7);
float weightMultiplier = ClassModifiers.GetWeightMultiplier(ClassManager.CurrentClass);
float num = currentStatus * weightMultiplier;
__instance.SetStatus((STATUSTYPE)7, num, true);
}
catch (Exception)
{
}
}
}
public interface IAbilityWithCooldown
{
void ResetCooldown();
}
public class CooldownUI
{
private static readonly Dictionary<string, CooldownUI> _instances = new Dictionary<string, CooldownUI>();
private readonly string _name;
private GameObject _root;
private Image _circle;
private TextMeshProUGUI _text;
private Vector2 _targetPos;
private float _cooldownDur;
private float _cooldownT;
private bool _active;
public static CooldownUI Get(string name, Vector2 anchoredPosition)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if (_instances.TryGetValue(name, out var value))
{
value._targetPos = anchoredPosition;
value.ApplyAnchors();
return value;
}
CooldownUI cooldownUI = new CooldownUI(name, anchoredPosition);
_instances[name] = cooldownUI;
return cooldownUI;
}
private CooldownUI(string name, Vector2 anchoredPosition)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
_name = name;
_targetPos = anchoredPosition;
CreateUI();
SetReadyVisuals();
}
private static GameObject EnsureCanvasRoot()
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.Find("ClassModF_CooldownRoot");
if ((Object)(object)val != (Object)null)
{
return val;
}
val = new GameObject("ClassModF_CooldownRoot");
Object.DontDestroyOnLoad((Object)(object)val);
Canvas val2 = val.AddComponent<Canvas>();
val2.renderMode = (RenderMode)0;
val2.sortingOrder = 5000;
CanvasScaler val3 = val.AddComponent<CanvasScaler>();
val3.uiScaleMode = (ScaleMode)0;
val3.referenceResolution = new Vector2(1920f, 1080f);
val.AddComponent<GraphicRaycaster>();
return val;
}
private void CreateUI()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Expected O, but got Unknown
//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
//IL_0205: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
_root = EnsureCanvasRoot();
GameObject val = new GameObject(_name + "_Circle");
val.transform.SetParent(_root.transform, false);
_circle = val.AddComponent<Image>();
UI_UseItemProgress val2 = Object.FindFirstObjectByType<UI_UseItemProgress>();
if ((Object)(object)Object.FindFirstObjectByType<UI_UseItemProgress>() != (Object)null && (Object)(object)Object.FindFirstObjectByType<UI_UseItemProgress>().fill != (Object)null)
{
_circle.sprite = val2.fill.sprite;
}
_circle.type = (Type)3;
_circle.fillMethod = (FillMethod)4;
_circle.fillOrigin = 2;
_circle.fillClockwise = false;
_circle.fillClockwise = false;
_circle.fillAmount = 0f;
((Graphic)_circle).color = new Color(0.2f, 1f, 0.2f, 0.9f);
((Behaviour)_circle).enabled = true;
ApplyAnchors();
GameObject val3 = new GameObject(_name + "_Text");
val3.transform.SetParent(((Component)_circle).transform, false);
_text = val3.AddComponent<TextMeshProUGUI>();
GameObject val4 = GameObject.Find("GAME/GUIManager");
GUIManager val5 = (((Object)(object)val4 != (Object)null) ? val4.GetComponent<GUIManager>() : null);
if ((Object)(object)val5 != (Object)null && (Object)(object)val5.heroDayText != (Object)null)
{
((TMP_Text)_text).font = ((TMP_Text)val5.heroDayText).font;
}
((TMP_Text)_text).alignment = (TextAlignmentOptions)514;
((Graphic)_text).color = Color.white;
((TMP_Text)_text).fontSize = 18f;
RectTransform rectTransform = ((TMP_Text)_text).rectTransform;
rectTransform.anchorMin = Vector2.zero;
rectTransform.anchorMax = Vector2.one;
rectTransform.offsetMin = Vector2.zero;
rectTransform.offsetMax = Vector2.zero;
}
private void ApplyAnchors()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_circle != (Object)null)
{
RectTransform rectTransform = ((Graphic)_circle).rectTransform;
rectTransform.anchorMin = new Vector2(1f, 0f);
rectTransform.anchorMax = new Vector2(1f, 0f);
rectTransform.pivot = new Vector2(1f, 0f);
rectTransform.anchoredPosition = _targetPos;
rectTransform.sizeDelta = new Vector2(75f, 75f);
}
}
private void SetReadyVisuals()
{
if ((Object)(object)_circle != (Object)null && (Object)(object)_text != (Object)null)
{
_circle.fillAmount = 1f;
((TMP_Text)_text).text = "Ready";
}
}
private void SetTickVisuals()
{
if ((Object)(object)_circle != (Object)null && (Object)(object)_text != (Object)null)
{
float fillAmount = ((_cooldownDur <= 0f) ? 0f : Mathf.Clamp01(1f - _cooldownT / _cooldownDur));
_circle.fillAmount = fillAmount;
int num = Mathf.FloorToInt(_cooldownT / 60f);
int num2 = Mathf.FloorToInt(_cooldownT % 60f);
((TMP_Text)_text).text = $"{num:00}:{num2:00}";
}
}
public void StartCooldown(float durationSeconds)
{
_cooldownDur = Mathf.Max(0f, durationSeconds);
_cooldownT = _cooldownDur;
_active = _cooldownDur > 0f;
if (_active)
{
SetTickVisuals();
}
else
{
SetReadyVisuals();
}
Show();
}
public void Update()
{
if (_active)
{
_cooldownT -= Time.deltaTime;
if (_cooldownT <= 0f)
{
_cooldownT = 0f;
_active = false;
SetReadyVisuals();
}
else
{
SetTickVisuals();
}
}
}
public void Show()
{
if ((Object)(object)_circle != (Object)null)
{
((Component)_circle).gameObject.SetActive(true);
}
if ((Object)(object)_text != (Object)null)
{
((Component)_text).gameObject.SetActive(true);
}
}
public void Hide()
{
if ((Object)(object)_circle != (Object)null)
{
((Component)_circle).gameObject.SetActive(false);
}
if ((Object)(object)_text != (Object)null)
{
((Component)_text).gameObject.SetActive(false);
}
}
public static void Remove(string name)
{
if (_instances.TryGetValue(name, out var value) && (Object)(object)value._circle != (Object)null)
{
Object.Destroy((Object)(object)((Component)value._circle).gameObject);
}
}
}
public class RestrictionPopup : MonoBehaviour
{
private static RestrictionPopup? instance;
private string message = "";
private float showUntil;
private void Awake()
{
instance = this;
}
private void OnGUI()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
if (Time.time < showUntil && !string.IsNullOrEmpty(message))
{
GUIStyle val = new GUIStyle(GUI.skin.label)
{
alignment = (TextAnchor)4,
fontSize = 20
};
val.normal.textColor = Color.black;
GUIStyle val2 = val;
float num = 400f;
float num2 = 30f;
GUI.Label(new Rect(((float)Screen.width - num) / 2f, (float)Screen.height / 2f - 100f, num, num2), message, val2);
}
}
public static void ShowMessage(string msg, float duration = 1f)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
if ((Object)(object)instance == (Object)null)
{
GameObject val = new GameObject("RestrictionPopup");
instance = val.AddComponent<RestrictionPopup>();
Object.DontDestroyOnLoad((Object)(object)val);
}
instance.message = msg;
instance.showUntil = Time.time + duration;
}
}
namespace ClassModF
{
[BepInPlugin("com.classmod.f", "ClassMod-F", "1.0.0")]
public class ClassModF : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <ResetCooldownsDelayed>d__3 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Scene scene;
public ClassModF <>4__this;
private float <timeout>5__1;
private IEnumerator<IAbilityWithCooldown> <>s__2;
private IAbilityWithCooldown <ability>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ResetCooldownsDelayed>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>s__2 = null;
<ability>5__3 = null;
<>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;
<>2__current = null;
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
<timeout>5__1 = 5f;
break;
case 3:
<>1__state = -1;
break;
}
if ((Object)(object)Character.localCharacter == (Object)null && <timeout>5__1 > 0f)
{
<timeout>5__1 -= Time.unscaledDeltaTime;
<>2__current = null;
<>1__state = 3;
return true;
}
<>s__2 = Object.FindObjectsByType<MonoBehaviour>((FindObjectsSortMode)0).OfType<IAbilityWithCooldown>().GetEnumerator();
try
{
while (<>s__2.MoveNext())
{
<ability>5__3 = <>s__2.Current;
<ability>5__3.ResetCooldown();
<ability>5__3 = null;
}
}
finally
{
if (<>s__2 != null)
{
<>s__2.Dispose();
}
}
<>s__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();
}
}
[CompilerGenerated]
private sealed class <SpawnStartingItemDelayed>d__4 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Scene scene;
public ClassModF <>4__this;
private float <timeout>5__1;
private string <itemPrefab>5__2;
private Item <item>5__3;
private Exception <ex>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnStartingItemDelayed>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<itemPrefab>5__2 = null;
<item>5__3 = null;
<ex>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Expected O, but got Unknown
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<timeout>5__1 = 5f;
goto IL_008c;
case 2:
<>1__state = -1;
goto IL_008c;
case 3:
<>1__state = -1;
GameUtils.instance.InstantiateAndGrab(<item>5__3, Character.localCharacter, 1);
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 4;
return true;
case 4:
{
<>1__state = -1;
goto IL_019f;
}
IL_008c:
if ((Object)(object)Character.localCharacter == (Object)null && <timeout>5__1 > 0f)
{
<timeout>5__1 -= Time.unscaledDeltaTime;
<>2__current = null;
<>1__state = 2;
return true;
}
if (!((Object)(object)Character.localCharacter != (Object)null))
{
break;
}
<itemPrefab>5__2 = <>4__this.GetStartingItemForClass(ClassManager.CurrentClass);
if (!string.IsNullOrEmpty(<itemPrefab>5__2))
{
<item>5__3 = null;
try
{
<item>5__3 = ObjectDatabaseAsset<ItemDatabase, Item>.GetObjectFromString(<itemPrefab>5__2);
}
catch (Exception ex)
{
<ex>5__4 = ex;
Debug.LogError((object)("[ClassMod-F] Error getting item: " + <ex>5__4.Message));
return false;
}
if ((Object)(object)<item>5__3 != (Object)null)
{
<>2__current = (object)new WaitForSeconds(8f);
<>1__state = 3;
return true;
}
goto IL_019f;
}
goto IL_01a7;
IL_01a7:
<itemPrefab>5__2 = null;
break;
IL_019f:
<item>5__3 = null;
goto IL_01a7;
}
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 readonly Harmony _harmony = new Harmony("com.classmod.f");
private void Awake()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
_harmony.PatchAll();
GameObject val = new GameObject("ClassUI");
val.AddComponent<ClassUI>();
Object.DontDestroyOnLoad((Object)(object)val);
SceneManager.sceneLoaded += OnSceneLoaded;
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
((MonoBehaviour)this).StartCoroutine(ResetCooldownsDelayed(scene));
if (!(((Scene)(ref scene)).name != "Airport"))
{
}
}
[IteratorStateMachine(typeof(<ResetCooldownsDelayed>d__3))]
private IEnumerator ResetCooldownsDelayed(Scene scene)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ResetCooldownsDelayed>d__3(0)
{
<>4__this = this,
scene = scene
};
}
[IteratorStateMachine(typeof(<SpawnStartingItemDelayed>d__4))]
private IEnumerator SpawnStartingItemDelayed(Scene scene)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnStartingItemDelayed>d__4(0)
{
<>4__this = this,
scene = scene
};
}
private string GetStartingItemForClass(PlayerClass cls)
{
if (1 == 0)
{
}
string result = cls switch
{
PlayerClass.Scout => "Energy Drink",
PlayerClass.Herbalist => "FirstAidKit",
PlayerClass.Forager => "Kingberry Purple",
PlayerClass.Ranger => "Sports Drink",
_ => null,
};
if (1 == 0)
{
}
return result;
}
private void Update()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "Airport")
{
ClassManager.Update();
}
}
}
public static class ClassAbilities
{
private static GameObject _container;
private static PlayerClass _lastClass = (PlayerClass)(-1);
public static void AssignAbility(PlayerClass cls)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
if ((Object)(object)Character.localCharacter == (Object)null)
{
return;
}
if ((Object)(object)_container == (Object)null)
{
_container = new GameObject("ClassModF_Abilities");
Object.DontDestroyOnLoad((Object)(object)_container);
}
if (_lastClass != cls || !HasAbilityFor(cls))
{
DestroyIfExists<ScoutAbility>();
DestroyIfExists<ForageAbility>();
DestroyIfExists<RangerAbility>();
DestroyIfExists<TinkererAbility>();
switch (cls)
{
case PlayerClass.Scout:
_container.AddComponent<ScoutAbility>();
break;
case PlayerClass.Forager:
_container.AddComponent<ForageAbility>();
break;
case PlayerClass.Herbalist:
_container.AddComponent<ForageAbility>();
break;
case PlayerClass.Ranger:
_container.AddComponent<RangerAbility>();
break;
case PlayerClass.Tinkerer:
_container.AddComponent<TinkererAbility>();
break;
}
_lastClass = cls;
}
}
private static void DestroyIfExists<T>() where T : Component
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
T val = (((Object)(object)_container != (Object)null) ? _container.GetComponent<T>() : default(T));
if ((Object)(object)val != (Object)null)
{
Object.Destroy((Object)(object)val);
}
}
private static bool HasAbilityFor(PlayerClass cls)
{
if (1 == 0)
{
}
bool result = cls switch
{
PlayerClass.Forager => (Object)(object)_container.GetComponent<ForageAbility>() != (Object)null,
PlayerClass.Herbalist => (Object)(object)_container.GetComponent<ForageAbility>() != (Object)null,
PlayerClass.Scout => (Object)(object)_container.GetComponent<ScoutAbility>() != (Object)null,
PlayerClass.Ranger => (Object)(object)_container.GetComponent<RangerAbility>() != (Object)null,
PlayerClass.Tinkerer => (Object)(object)_container.GetComponent<TinkererAbility>() != (Object)null,
_ => false,
};
if (1 == 0)
{
}
return result;
}
}
public static class ClassModifiers
{
public static float GetStaminaMultiplier(PlayerClass playerClass)
{
return 1f;
}
public static float GetWeightMultiplier(PlayerClass playerClass)
{
return 1f;
}
public static Dictionary<int, float> GetAllAfflictionMultipliers(PlayerClass playerClass)
{
Dictionary<int, float> dictionary = new Dictionary<int, float>();
for (int i = 0; i < 9; i++)
{
dictionary[i] = 1f;
}
return dictionary;
}
public static float GetAfflictionMultiplier(PlayerClass playerClass, int status)
{
return 1f;
}
}
public class ClassUI : MonoBehaviour
{
private static readonly Dictionary<int, string> AfflictionNames = new Dictionary<int, string>
{
{ 1, "Hunger Rate" },
{ 2, "Cold Damage" },
{ 8, "Heat Damage" },
{ 0, "Fall Damage" },
{ 3, "Poison Damage" },
{ 6, "Drowsiness" }
};
private static bool showHUD = false;
private static readonly KeyCode toggleKey = (KeyCode)273;
private void Awake()
{
SceneManager.sceneLoaded += OnSceneLoaded;
}
private void Start()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
ApplySceneGate(((Scene)(ref activeScene)).name);
}
private void OnDestroy()
{
SceneManager.sceneLoaded -= OnSceneLoaded;
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
ApplySceneGate(((Scene)(ref scene)).name);
}
private void ApplySceneGate(string sceneName)
{
bool enabled = sceneName == "Airport";
showHUD = false;
((Behaviour)this).enabled = enabled;
}
private void Update()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if (Input.GetKeyDown(toggleKey))
{
showHUD = !showHUD;
}
}
private void OnGUI()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
if (!showHUD)
{
return;
}
GUIStyle val = new GUIStyle(GUI.skin.label)
{
fontSize = 12
};
val.normal.textColor = Color.cyan;
GUIStyle val2 = val;
GUILayout.BeginArea(new Rect(10f, 20f, 400f, 600f));
GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
GUILayout.Label($"Current Class: {ClassManager.CurrentClass}", val2, Array.Empty<GUILayoutOption>());
GUILayout.Space(10f);
foreach (KeyValuePair<int, float> cachedAfflictionMultiplier in ClassManager.CachedAfflictionMultipliers)
{
float value = cachedAfflictionMultiplier.Value;
if (!Mathf.Approximately(value, 1f))
{
string arg = (AfflictionNames.ContainsKey(cachedAfflictionMultiplier.Key) ? AfflictionNames[cachedAfflictionMultiplier.Key] : ((object)cachedAfflictionMultiplier.Key).ToString());
GUILayout.Label($"{arg}: {value}x", val2, Array.Empty<GUILayoutOption>());
}
}
GUILayout.Space(10f);
string classDescription = GetClassDescription(ClassManager.CurrentClass);
if (!string.IsNullOrEmpty(classDescription))
{
GUILayout.Label("Class Description:", val2, Array.Empty<GUILayoutOption>());
GUILayout.Label(classDescription, val2, Array.Empty<GUILayoutOption>());
GUILayout.Space(10f);
}
GUILayout.Label("Press ← or → to change class", val2, Array.Empty<GUILayoutOption>());
GUILayout.Label($"Press {toggleKey} to toggle HUD", val2, Array.Empty<GUILayoutOption>());
GUILayout.EndVertical();
GUILayout.EndArea();
}
private string GetClassDescription(PlayerClass playerClass)
{
if (1 == 0)
{
}
string result = playerClass switch
{
PlayerClass.Scout => "The Scout excels in speed. Ability: Adrenaline Rush - Press F to activate, Push your body into overdrive, moving faster and climbing with speed for a short time. causes Heavy drowsiness after use.",
PlayerClass.Forager => "The Forager is a resourceful survivor who gathers food from the land. Ability: Forage Food - Press F to activate, searching the surroundings for edible resources based on the current biome, spawning fruits, berries, or mushrooms. Physically demanding, causes drowsiness after use.",
PlayerClass.Herbalist => "The Herbalist specializes in natural remedies and healing. Ability: Forage Herbs - Press F to activate, scanning the area for medicinal items based on the biome, spawning herbs, roots, or healing supplies. Physically demanding, causes drowsiness after use.",
PlayerClass.Ranger => "The Ranger masters survival instincts with superior stamina and resilience. Ability: Survival Instinct - Press F to activate, push your limits to add 50 bonus stamina and become invisible for 8 seconds. causes Heavy drowsiness after use.",
PlayerClass.Tinkerer => "The Tinkerer is an inventive engineer who crafts useful tools from scavenged parts. Ability: Tinker Tools - Press F to activate, assembles a random equipment from scavenged parts. Highly demanding work, causes significant drowsiness after use.",
_ => "",
};
if (1 == 0)
{
}
return result;
}
}
public class ScoutAbility : MonoBehaviour, IAbilityWithCooldown
{
[CompilerGenerated]
private sealed class <ApplyDrowsyAfterDelay>d__18 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Character local;
public float delay;
public ScoutAbility <>4__this;
private Affliction_AdjustDrowsyOverTime <drowsyAffliction>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ApplyDrowsyAfterDelay>d__18(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<drowsyAffliction>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delay);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)local != (Object)null)
{
<drowsyAffliction>5__1 = new Affliction_AdjustDrowsyOverTime(0.075f, 10f);
local.refs.afflictions.AddAffliction((Affliction)(object)<drowsyAffliction>5__1, false);
<drowsyAffliction>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();
}
}
public KeyCode abilityKey = (KeyCode)102;
public float holdTime = 0f;
public float cooldownSeconds = 600f;
public float duration = 8f;
public float moveSpeedMod = 0.5f;
public float climbSpeedMod = 1.5f;
public float drowsyOnEnd = 0.75f;
public float injuryOnEnd;
public float climbDelay;
private float _hold;
private float _cooldownLeft;
private bool _uiAvailable;
private CooldownUI? _ui;
private void Start()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
try
{
_ui = CooldownUI.Get("Scout FasterBoi", new Vector2(-20f, 140f));
_uiAvailable = true;
_ui.Hide();
}
catch
{
_uiAvailable = false;
}
}
private void Update()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_014c: Unknown result type (might be due to invalid IL or missing references)
//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
Character localCharacter = Character.localCharacter;
if ((Object)(object)localCharacter == (Object)null)
{
return;
}
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "Airport")
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (ClassManager.CurrentClass != PlayerClass.Scout)
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (_uiAvailable && _ui != null)
{
_ui.Show();
}
if (_cooldownLeft > 0f)
{
_cooldownLeft -= Time.deltaTime;
if (_cooldownLeft < 0f)
{
_cooldownLeft = 0f;
}
}
if (_uiAvailable && _ui != null)
{
_ui.Update();
}
if (_cooldownLeft > 0f)
{
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
return;
}
if (Input.GetKey(abilityKey))
{
_hold += Time.deltaTime;
if (_hold >= holdTime)
{
_hold = 0f;
Activate(localCharacter);
}
}
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
}
private void OnDisable()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void OnDestroy()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void Activate(Character local)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: 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_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
try
{
Affliction_FasterBoi val = new Affliction_FasterBoi
{
totalTime = duration,
moveSpeedMod = moveSpeedMod,
climbSpeedMod = climbSpeedMod,
drowsyOnEnd = 0f,
climbDelay = climbDelay
};
local.refs.afflictions.AddAffliction((Affliction)(object)val, false);
((MonoBehaviour)this).StartCoroutine(ApplyDrowsyAfterDelay(local, duration));
_cooldownLeft = cooldownSeconds;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(cooldownSeconds);
}
Debug.Log((object)($"[ScoutAbility] Activated: duration {duration}s, " + $"speed x{moveSpeedMod}, climb x{climbSpeedMod}, " + $"drowsy {drowsyOnEnd} per second for 10s after end."));
}
catch (Exception arg)
{
Debug.LogError((object)$"[ScoutAbility] Exception: {arg}");
}
}
[IteratorStateMachine(typeof(<ApplyDrowsyAfterDelay>d__18))]
private IEnumerator ApplyDrowsyAfterDelay(Character local, float delay)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ApplyDrowsyAfterDelay>d__18(0)
{
<>4__this = this,
local = local,
delay = delay
};
}
public void ResetCooldown()
{
_cooldownLeft = 0f;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(0f);
_ui.Show();
}
}
}
public enum ForageBiomeType
{
Shore,
Tropics,
Roots,
Alpine,
Mesa,
Caldera,
Kiln,
Peak
}
public class ForageAbility : MonoBehaviour, IAbilityWithCooldown
{
[CompilerGenerated]
private sealed class <SpawnForageItemDelayed>d__12 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string itemPrefab;
public Character local;
public ForageAbility <>4__this;
private Item <item>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnForageItemDelayed>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<item>5__1 = 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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (!string.IsNullOrEmpty(itemPrefab) && (Object)local != (Object)null)
{
<item>5__1 = ObjectDatabaseAsset<ItemDatabase, Item>.GetObjectFromString(itemPrefab);
if ((Object)(object)<item>5__1 != (Object)null)
{
GameUtils.instance.InstantiateAndGrab(<item>5__1, local, 1);
}
<item>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();
}
}
public KeyCode abilityKey = (KeyCode)102;
public float holdTime = 0f;
public float cooldownSeconds = 300f;
private float _hold;
private float _cooldownLeft;
private bool _uiAvailable;
private CooldownUI? _ui;
private void Start()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
try
{
_ui = CooldownUI.Get("Forage Ability", new Vector2(-20f, 140f));
_uiAvailable = true;
_ui.Hide();
}
catch
{
_uiAvailable = false;
}
}
private void Update()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
Character localCharacter = Character.localCharacter;
if ((Object)localCharacter == (Object)null)
{
return;
}
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "Airport")
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (ClassManager.CurrentClass != PlayerClass.Herbalist && ClassManager.CurrentClass != PlayerClass.Forager)
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (_uiAvailable && _ui != null)
{
_ui.Show();
}
if (_cooldownLeft > 0f)
{
_cooldownLeft -= Time.deltaTime;
if (_cooldownLeft < 0f)
{
_cooldownLeft = 0f;
}
}
if (_uiAvailable && _ui != null)
{
_ui.Update();
}
if (_cooldownLeft > 0f)
{
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
return;
}
if (Input.GetKey(abilityKey))
{
_hold += Time.deltaTime;
if (_hold >= holdTime)
{
_hold = 0f;
TryForage(localCharacter);
}
}
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
}
private void OnDisable()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void OnDestroy()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void TryForage(Character local)
{
try
{
string forageItemForBiome = GetForageItemForBiome();
string forageMessage = GetForageMessage(forageItemForBiome);
if (!string.IsNullOrEmpty(forageMessage))
{
RestrictionPopup.ShowMessage(forageMessage, 5f);
}
else if (string.IsNullOrEmpty(forageItemForBiome))
{
RestrictionPopup.ShowMessage("you find nothing worth taking", 5f);
}
if (!string.IsNullOrEmpty(forageItemForBiome))
{
((MonoBehaviour)this).StartCoroutine(SpawnForageItemDelayed(forageItemForBiome, local));
}
local.refs.afflictions.AddStatus((STATUSTYPE)6, 0.25f, false, true, true);
_cooldownLeft = cooldownSeconds;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(cooldownSeconds);
}
}
catch (Exception arg)
{
Debug.LogError((object)$"[ForageAbility] Exception: {arg}");
}
}
[IteratorStateMachine(typeof(<SpawnForageItemDelayed>d__12))]
private IEnumerator SpawnForageItemDelayed(string itemPrefab, Character local)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnForageItemDelayed>d__12(0)
{
<>4__this = this,
itemPrefab = itemPrefab,
local = local
};
}
private string GetForageItemForBiome()
{
if (ClassManager.CurrentClass == PlayerClass.Forager)
{
return GetForageFood();
}
if (ClassManager.CurrentClass == PlayerClass.Herbalist)
{
return GetForageHerbs();
}
return null;
}
private ForageBiomeType GetCurrentBiome()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected I4, but got Unknown
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Invalid comparison between Unknown and I4
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Invalid comparison between Unknown and I4
try
{
MapHandler instance = Singleton<MapHandler>.Instance;
if ((Object)(object)instance != (Object)null)
{
Segment currentSegment = instance.GetCurrentSegment();
BiomeType currentBiome = instance.GetCurrentBiome();
switch ((int)currentSegment)
{
case 3:
return ForageBiomeType.Caldera;
case 4:
return ForageBiomeType.Kiln;
case 5:
return ForageBiomeType.Peak;
case 1:
if ((int)currentBiome == 7)
{
return ForageBiomeType.Roots;
}
return ForageBiomeType.Tropics;
case 2:
if ((int)currentBiome == 2)
{
return ForageBiomeType.Alpine;
}
return ForageBiomeType.Mesa;
default:
return ForageBiomeType.Shore;
}
}
}
catch (Exception ex)
{
Debug.LogError((object)("[ForageAbility] Error getting biome: " + ex.Message));
}
return ForageBiomeType.Shore;
}
private string GetForageFood()
{
ForageBiomeType currentBiome = GetCurrentBiome();
List<(string, float)> list = new List<(string, float)>();
switch (currentBiome)
{
case ForageBiomeType.Shore:
list.Add(("Item_Coconut", 1f));
list.Add(("Apple Berry Red", 1f));
list.Add(("Apple Berry Yellow", 1f));
list.Add(("Mushroom Normie", 1f));
list.Add(("Mushroom Lace", 1f));
list.Add(("Mushroom Cluster", 1f));
list.Add(("Mushroom Chubby", 1f));
break;
case ForageBiomeType.Tropics:
list.Add(("Item_Coconut", 1f));
list.Add(("Apple Berry Red", 1f));
list.Add(("Apple Berry Yellow", 1f));
list.Add(("Pepper Berry", 1f));
list.Add(("Berrynana Yellow", 1f));
list.Add(("Berrynana Blue", 1f));
list.Add(("Berrynana Brown", 1f));
list.Add(("Clusterberry Yellow", 1f));
list.Add(("Clusterberry Black", 1f));
list.Add(("Mushroom Normie", 1f));
list.Add(("Mushroom Lace", 1f));
list.Add(("Mushroom Cluster", 1f));
list.Add(("Mushroom Chubby", 1f));
list.Add(("Kingberry Purple", 1f));
break;
case ForageBiomeType.Roots:
list.Add(("Shroomberry_Red", 1f));
list.Add(("Shroomberry_Yellow", 1f));
list.Add(("Shroomberry_Purple", 0.5f));
list.Add(("Mushroom Normie", 1f));
list.Add(("Mushroom Lace", 1f));
list.Add(("Mushroom Cluster", 1f));
list.Add(("Mushroom Chubby", 1f));
break;
case ForageBiomeType.Alpine:
list.Add(("Winterberry Orange", 1f));
list.Add(("Napberry", 0.1f));
break;
case ForageBiomeType.Mesa:
list.Add(("Item_Coconut", 1f));
list.Add(("Prickleberry_Red", 1f));
list.Add(("Mushroom Normie", 1f));
list.Add(("Mushroom Lace", 1f));
list.Add(("Mushroom Cluster", 1f));
list.Add(("Mushroom Chubby", 1f));
break;
case ForageBiomeType.Caldera:
list.Add(("NestEgg", 1f));
break;
case ForageBiomeType.Kiln:
list.Add(("Airplane Food", 1f));
list.Add(("Granola Bar", 1f));
list.Add(("TrailMix", 1f));
break;
default:
return null;
}
return SelectWeightedItem(list);
}
private string GetForageHerbs()
{
ForageBiomeType currentBiome = GetCurrentBiome();
List<(string, float)> list = new List<(string, float)>();
switch (currentBiome)
{
case ForageBiomeType.Shore:
list.Add(("MedicinalRoot", 1f));
list.Add(("HealingPuffShroom", 0.5f));
break;
case ForageBiomeType.Tropics:
list.Add(("MedicinalRoot", 1f));
list.Add(("Clusterberry Red", 1f));
list.Add(("HealingPuffShroom", 0.5f));
break;
case ForageBiomeType.Roots:
list.Add(("MedicinalRoot", 1f));
list.Add(("HealingPuffShroom", 0.5f));
break;
case ForageBiomeType.Alpine:
list.Add(("HealingPuffShroom", 1f));
list.Add(("Winterberry Yellow", 0.5f));
list.Add(("Napberry", 0.1f));
break;
case ForageBiomeType.Mesa:
list.Add(("Prickleberry_Gold", 1f));
list.Add(("HealingPuffShroom", 0.5f));
break;
case ForageBiomeType.Caldera:
list.Add(("Sports Drink", 1f));
break;
case ForageBiomeType.Kiln:
list.Add(("Lollipop", 1f));
list.Add(("Energy Drink", 1f));
list.Add(("FortifiedMilk", 1f));
list.Add(("Sports Drink", 1f));
break;
default:
return null;
}
return SelectWeightedItem(list);
}
private string SelectWeightedItem(List<(string item, float weight)> weightedItems)
{
if (weightedItems == null || weightedItems.Count == 0)
{
return null;
}
float num = 0f;
foreach (var weightedItem in weightedItems)
{
num += weightedItem.weight;
}
float num2 = Random.value * num;
float num3 = 0f;
foreach (var weightedItem2 in weightedItems)
{
num3 += weightedItem2.weight;
if (num2 <= num3)
{
return weightedItem2.item;
}
}
return weightedItems[weightedItems.Count - 1].item;
}
private string GetForageMessage(string itemFound)
{
if (string.IsNullOrEmpty(itemFound))
{
return null;
}
ForageBiomeType currentBiome = GetCurrentBiome();
if (ClassManager.CurrentClass == PlayerClass.Forager)
{
if (currentBiome == ForageBiomeType.Kiln)
{
return "you find something in a luggage";
}
}
else if (ClassManager.CurrentClass == PlayerClass.Herbalist && (currentBiome == ForageBiomeType.Caldera || currentBiome == ForageBiomeType.Kiln))
{
return "you find something in a luggage";
}
return null;
}
public void ResetCooldown()
{
_cooldownLeft = 0f;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(0f);
_ui.Show();
}
}
}
public class RangerAbility : MonoBehaviour, IAbilityWithCooldown
{
[CompilerGenerated]
private sealed class <ApplyDrowsyAfterDelay>d__15 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Character local;
public float delay;
public RangerAbility <>4__this;
private Affliction_AdjustDrowsyOverTime <drowsyAffliction>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ApplyDrowsyAfterDelay>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<drowsyAffliction>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delay);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if ((Object)(object)local != (Object)null)
{
<drowsyAffliction>5__1 = new Affliction_AdjustDrowsyOverTime(0.075f, 10f);
local.refs.afflictions.AddAffliction((Affliction)(object)<drowsyAffliction>5__1, false);
<drowsyAffliction>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();
}
}
public KeyCode abilityKey = (KeyCode)102;
public float holdTime = 0f;
public float cooldownSeconds = 600f;
public int effectType = 6;
public float drowsyAmount = 7.5f;
private float _hold;
private float _cooldownLeft;
private bool _uiAvailable;
private CooldownUI? _ui;
private void Start()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
try
{
_ui = CooldownUI.Get("NapBerry Ability", new Vector2(-20f, 140f));
_uiAvailable = true;
_ui.Hide();
}
catch
{
_uiAvailable = false;
}
}
private void Update()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0190: Unknown result type (might be due to invalid IL or missing references)
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
Character localCharacter = Character.localCharacter;
if ((Object)(object)localCharacter == (Object)null)
{
return;
}
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "Airport")
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (ClassManager.CurrentClass != PlayerClass.Ranger)
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (_uiAvailable && _ui != null)
{
_ui.Show();
}
if (_cooldownLeft > 0f)
{
_cooldownLeft -= Time.deltaTime;
if (_cooldownLeft < 0f)
{
_cooldownLeft = 0f;
}
}
if (_uiAvailable && _ui != null)
{
_ui.Update();
if (_cooldownLeft <= 0f)
{
_ui.Show();
}
}
if (_cooldownLeft > 0f)
{
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
return;
}
if (Input.GetKey(abilityKey))
{
_hold += Time.deltaTime;
if (_hold >= holdTime)
{
_hold = 0f;
ApplyNapBerry(localCharacter);
}
}
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
}
private void OnDisable()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void OnDestroy()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void ApplyNapBerry(Character local)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
try
{
Affliction_Invincibility val = new Affliction_Invincibility
{
totalTime = 8f
};
local.refs.afflictions.AddAffliction((Affliction)(object)val, false);
local.AddExtraStamina(0.5f);
((MonoBehaviour)this).StartCoroutine(ApplyDrowsyAfterDelay(local, 8f));
_cooldownLeft = cooldownSeconds;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(cooldownSeconds);
}
Debug.Log((object)"[RangerAbility] Activated Survival Instinct: 8s invincibility + 50% bonus stamina, then drowsy.");
}
catch (Exception arg)
{
Debug.LogError((object)$"[RangerAbility] Exception: {arg}");
}
}
public void ResetCooldown()
{
_cooldownLeft = 0f;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(0f);
_ui.Show();
}
}
[IteratorStateMachine(typeof(<ApplyDrowsyAfterDelay>d__15))]
private IEnumerator ApplyDrowsyAfterDelay(Character local, float delay)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ApplyDrowsyAfterDelay>d__15(0)
{
<>4__this = this,
local = local,
delay = delay
};
}
}
public class TinkererAbility : MonoBehaviour, IAbilityWithCooldown
{
[CompilerGenerated]
private sealed class <SpawnTinkerItemDelayed>d__12 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string itemPrefab;
public Character local;
public TinkererAbility <>4__this;
private Item <item>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnTinkerItemDelayed>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<item>5__1 = 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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (!string.IsNullOrEmpty(itemPrefab) && (Object)local != (Object)null)
{
<item>5__1 = ObjectDatabaseAsset<ItemDatabase, Item>.GetObjectFromString(itemPrefab);
if ((Object)(object)<item>5__1 != (Object)null)
{
GameUtils.instance.InstantiateAndGrab(<item>5__1, local, 1);
}
<item>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();
}
}
public KeyCode abilityKey = (KeyCode)102;
public float holdTime = 0f;
public float cooldownSeconds = 600f;
private float _hold;
private float _cooldownLeft;
private bool _uiAvailable;
private CooldownUI? _ui;
private void Start()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
try
{
_ui = CooldownUI.Get("Tinker Ability", new Vector2(-20f, 140f));
_uiAvailable = true;
_ui.Hide();
}
catch
{
_uiAvailable = false;
}
}
private void Update()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
Character localCharacter = Character.localCharacter;
if ((Object)localCharacter == (Object)null)
{
return;
}
Scene activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name == "Airport")
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (ClassManager.CurrentClass != PlayerClass.Tinkerer)
{
if (_uiAvailable && _ui != null)
{
_ui.Hide();
}
return;
}
if (_uiAvailable && _ui != null)
{
_ui.Show();
}
if (_cooldownLeft > 0f)
{
_cooldownLeft -= Time.deltaTime;
if (_cooldownLeft < 0f)
{
_cooldownLeft = 0f;
}
}
if (_uiAvailable && _ui != null)
{
_ui.Update();
}
if (_cooldownLeft > 0f)
{
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
return;
}
if (Input.GetKey(abilityKey))
{
_hold += Time.deltaTime;
if (_hold >= holdTime)
{
_hold = 0f;
TryTinker(localCharacter);
}
}
if (Input.GetKeyUp(abilityKey))
{
_hold = 0f;
}
}
private void OnDisable()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void OnDestroy()
{
if (_ui != null)
{
_ui.Hide();
}
}
private void TryTinker(Character local)
{
try
{
string tinkerItemForBiome = GetTinkerItemForBiome();
string tinkerMessage = GetTinkerMessage(tinkerItemForBiome);
if (!string.IsNullOrEmpty(tinkerMessage))
{
RestrictionPopup.ShowMessage(tinkerMessage, 5f);
}
else if (string.IsNullOrEmpty(tinkerItemForBiome))
{
RestrictionPopup.ShowMessage("you find nothing worth tinkering with", 5f);
}
if (!string.IsNullOrEmpty(tinkerItemForBiome))
{
((MonoBehaviour)this).StartCoroutine(SpawnTinkerItemDelayed(tinkerItemForBiome, local));
}
local.refs.afflictions.AddStatus((STATUSTYPE)6, 0.5f, false, true, true);
_cooldownLeft = cooldownSeconds;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(cooldownSeconds);
}
}
catch (Exception arg)
{
Debug.LogError((object)$"[TinkererAbility] Exception: {arg}");
}
}
[IteratorStateMachine(typeof(<SpawnTinkerItemDelayed>d__12))]
private IEnumerator SpawnTinkerItemDelayed(string itemPrefab, Character local)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnTinkerItemDelayed>d__12(0)
{
<>4__this = this,
itemPrefab = itemPrefab,
local = local
};
}
private string GetTinkerItemForBiome()
{
ForageBiomeType currentBiome = GetCurrentBiome();
List<(string, float)> list = new List<(string, float)>();
switch (currentBiome)
{
case ForageBiomeType.Shore:
list.Add(("ClimbingSpike", 1f));
list.Add(("PortableStovetopItem", 0.5f));
list.Add(("RopeShooter", 1f));
list.Add(("RopeSpool", 1f));
list.Add(("ScoutCannonItem", 1f));
break;
case ForageBiomeType.Tropics:
list.Add(("ClimbingSpike", 1f));
list.Add(("PortableStovetopItem", 0.5f));
list.Add(("RopeShooter", 1f));
list.Add(("RopeSpool", 1f));
list.Add(("ScoutCannonItem", 1f));
break;
case ForageBiomeType.Roots:
list.Add(("ClimbingSpike", 1f));
list.Add(("PortableStovetopItem", 0.5f));
list.Add(("RopeShooter", 1f));
list.Add(("RopeSpool", 1f));
list.Add(("ScoutCannonItem", 1f));
break;
case ForageBiomeType.Alpine:
list.Add(("ClimbingSpike", 1f));
list.Add(("PortableStovetopItem", 0.5f));
list.Add(("RopeShooter", 1f));
list.Add(("RopeSpool", 1f));
list.Add(("ScoutCannonItem", 1f));
break;
case ForageBiomeType.Mesa:
list.Add(("ClimbingSpike", 1f));
list.Add(("PortableStovetopItem", 0.5f));
list.Add(("RopeShooter", 1f));
list.Add(("RopeSpool", 1f));
list.Add(("ScoutCannonItem", 1f));
break;
case ForageBiomeType.Caldera:
list.Add(("ClimbingSpike", 1f));
list.Add(("PortableStovetopItem", 0.5f));
list.Add(("RopeShooter", 1f));
list.Add(("RopeSpool", 1f));
list.Add(("ScoutCannonItem", 1f));
break;
case ForageBiomeType.Kiln:
list.Add(("ClimbingSpike", 1f));
list.Add(("PortableStovetopItem", 0.5f));
list.Add(("RopeShooter", 1f));
list.Add(("RopeSpool", 1f));
list.Add(("ScoutCannonItem", 1f));
break;
default:
return null;
}
return SelectWeightedItem(list);
}
private ForageBiomeType GetCurrentBiome()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected I4, but got Unknown
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Invalid comparison between Unknown and I4
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Invalid comparison between Unknown and I4
try
{
MapHandler instance = Singleton<MapHandler>.Instance;
if ((Object)(object)instance != (Object)null)
{
Segment currentSegment = instance.GetCurrentSegment();
BiomeType currentBiome = instance.GetCurrentBiome();
switch ((int)currentSegment)
{
case 3:
return ForageBiomeType.Caldera;
case 4:
return ForageBiomeType.Kiln;
case 5:
return ForageBiomeType.Peak;
case 1:
if ((int)currentBiome == 7)
{
return ForageBiomeType.Roots;
}
return ForageBiomeType.Tropics;
case 2:
if ((int)currentBiome == 2)
{
return ForageBiomeType.Alpine;
}
return ForageBiomeType.Mesa;
default:
return ForageBiomeType.Shore;
}
}
}
catch (Exception ex)
{
Debug.LogError((object)("[TinkererAbility] Error getting biome: " + ex.Message));
}
return ForageBiomeType.Shore;
}
private string SelectWeightedItem(List<(string item, float weight)> weightedItems)
{
if (weightedItems == null || weightedItems.Count == 0)
{
return null;
}
float num = 0f;
foreach (var weightedItem in weightedItems)
{
num += weightedItem.weight;
}
float num2 = Random.value * num;
float num3 = 0f;
foreach (var weightedItem2 in weightedItems)
{
num3 += weightedItem2.weight;
if (num2 <= num3)
{
return weightedItem2.item;
}
}
return weightedItems[weightedItems.Count - 1].item;
}
private string GetTinkerMessage(string itemFound)
{
if (string.IsNullOrEmpty(itemFound))
{
return null;
}
ForageBiomeType currentBiome = GetCurrentBiome();
if (currentBiome == ForageBiomeType.Kiln)
{
return "you tinker together some useful tools";
}
return null;
}
public void ResetCooldown()
{
_cooldownLeft = 0f;
if (_uiAvailable && _ui != null)
{
_ui.StartCooldown(0f);
_ui.Show();
}
}
}
}
