using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using IL.RoR2;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour.HookGen;
using On.RoR2;
using RoR2;
using RoR2.ContentManagement;
using UnityEngine;
using UnityEngine.Networking;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("BonusJump")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BonusJump")]
[assembly: AssemblyTitle("BonusJump")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace TPDespair.BonusJump;
public class ServerBonusJumpBehavior : ItemBehavior
{
private enum JumpState
{
Cooldown,
Waiting,
Available
}
internal static BuffIndex availableBuff = (BuffIndex)(-1);
internal static BuffIndex waitingBuff = (BuffIndex)(-1);
internal static BuffIndex cooldownBuff = (BuffIndex)(-1);
private CharacterMotor motor;
private JumpState jumpState = JumpState.Cooldown;
private float timer = -1f;
private bool cleanseCooldown = false;
private bool requestedUsage = false;
private float timeSinceLastGrounded = 0.25f;
private float groundThreshold = 0.25f;
public void Awake()
{
((Behaviour)this).enabled = false;
}
public void OnEnable()
{
if (Object.op_Implicit((Object)(object)base.body))
{
CharacterMotor characterMotor = base.body.characterMotor;
if (Object.op_Implicit((Object)(object)characterMotor))
{
motor = characterMotor;
}
jumpState = JumpState.Cooldown;
float value = BonusJumpPlugin.JumpCooldown.Value;
if (value >= 1f)
{
timer = value;
}
groundThreshold = BonusJumpPlugin.GroundThreshold.Value;
timeSinceLastGrounded = groundThreshold;
ClearDisplayBuffs();
}
}
public void OnDisable()
{
if (Object.op_Implicit((Object)(object)base.body))
{
ClearDisplayBuffs();
}
}
public void FixedUpdate()
{
if (NetworkServer.active && timer >= 0f && Object.op_Implicit((Object)(object)base.body) && Object.op_Implicit((Object)(object)motor))
{
UpdateGroundTracking();
UpdateJumpState();
UpdateBuffDisplay();
}
}
private void UpdateGroundTracking()
{
float fixedDeltaTime = Time.fixedDeltaTime;
if (motor.isGrounded)
{
timeSinceLastGrounded = 0f;
}
else
{
timeSinceLastGrounded += fixedDeltaTime;
}
if (timeSinceLastGrounded <= groundThreshold)
{
timer = Mathf.Max(0f, timer - fixedDeltaTime);
}
}
private void UpdateJumpState()
{
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Invalid comparison between Unknown and I4
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
if (jumpState == JumpState.Cooldown && timer <= 0f)
{
jumpState = JumpState.Available;
}
if (jumpState == JumpState.Available && requestedUsage)
{
jumpState = JumpState.Waiting;
requestedUsage = false;
}
if (jumpState == JumpState.Waiting && motor.isGrounded)
{
if (cleanseCooldown)
{
jumpState = JumpState.Available;
timer = 0f;
}
else
{
jumpState = JumpState.Cooldown;
float num = BonusJumpPlugin.JumpCooldown.Value;
float value = BonusJumpPlugin.CloudCompat.Value;
if (value > 0f && (int)BonusJumpPlugin.RainbowCloudItem != -1)
{
Inventory inventory = base.body.inventory;
if (Object.op_Implicit((Object)(object)inventory))
{
int itemCount = inventory.GetItemCount(BonusJumpPlugin.RainbowCloudItem);
if (itemCount > 0)
{
num *= 1f - Util.ConvertAmplificationPercentageIntoReductionPercentage(value * 100f * (float)itemCount) / 100f;
}
}
}
timer = Mathf.Max(1f, num);
}
}
if (jumpState == JumpState.Cooldown && cleanseCooldown)
{
jumpState = JumpState.Available;
timer = 0f;
}
if (jumpState != JumpState.Waiting)
{
cleanseCooldown = false;
}
}
private void ClearDisplayBuffs()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
if (NetworkServer.active)
{
base.body.SetBuffCount(availableBuff, 0);
base.body.SetBuffCount(waitingBuff, 0);
base.body.SetBuffCount(cooldownBuff, 0);
}
}
private void UpdateBuffDisplay()
{
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
if (jumpState == JumpState.Available)
{
if (!base.body.HasBuff(availableBuff))
{
base.body.SetBuffCount(availableBuff, 1);
}
if (base.body.HasBuff(waitingBuff))
{
base.body.SetBuffCount(waitingBuff, 0);
}
if (base.body.HasBuff(cooldownBuff))
{
base.body.SetBuffCount(cooldownBuff, 0);
}
return;
}
if (base.body.HasBuff(availableBuff))
{
base.body.SetBuffCount(availableBuff, 0);
}
if (jumpState == JumpState.Waiting)
{
if (!base.body.HasBuff(waitingBuff))
{
base.body.SetBuffCount(waitingBuff, 1);
}
if (base.body.HasBuff(cooldownBuff))
{
base.body.SetBuffCount(cooldownBuff, 0);
}
return;
}
if (base.body.HasBuff(waitingBuff))
{
base.body.SetBuffCount(waitingBuff, 0);
}
int num = Mathf.Max(1, Mathf.CeilToInt(timer));
int buffCount = base.body.GetBuffCount(cooldownBuff);
if (buffCount != num)
{
base.body.SetBuffCount(cooldownBuff, num);
}
}
public void CleanseCooldown()
{
if (NetworkServer.active)
{
cleanseCooldown = true;
}
}
public void ApplyUsageRequest()
{
if (NetworkServer.active)
{
requestedUsage = true;
}
}
}
public class AuthBonusJumpBehavior : ItemBehavior
{
internal static BuffIndex availableBuff = (BuffIndex)(-1);
internal static BuffIndex waitingBuff = (BuffIndex)(-1);
private CharacterMotor motor;
private bool broadcastedUsage = false;
private bool dontConsumeBonus = false;
private int prevJumpCount = 0;
private float timeSinceLastChanged = 0f;
public void Awake()
{
((Behaviour)this).enabled = false;
}
public void OnEnable()
{
if (Object.op_Implicit((Object)(object)base.body))
{
CharacterMotor characterMotor = base.body.characterMotor;
if (Object.op_Implicit((Object)(object)characterMotor))
{
motor = characterMotor;
}
}
}
public void FixedUpdate()
{
if (IsAuthority() && Object.op_Implicit((Object)(object)base.body) && Object.op_Implicit((Object)(object)motor))
{
UpdateJumpTracking();
UpdateJumpState();
}
}
private void UpdateJumpTracking()
{
if (motor.jumpCount != prevJumpCount)
{
dontConsumeBonus = false;
if (ReachedMaxJumpCount() && (timeSinceLastChanged <= 0.125f || motor.jumpCount - prevJumpCount > 1))
{
dontConsumeBonus = true;
}
timeSinceLastChanged = 0f;
prevJumpCount = motor.jumpCount;
}
else
{
timeSinceLastChanged += Time.fixedDeltaTime;
}
}
private void UpdateJumpState()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
if (base.body.HasBuff(availableBuff) && ReachedMaxJumpCount() && !dontConsumeBonus && !broadcastedUsage)
{
broadcastedUsage = true;
base.body.AddTimedBuffAuthority(waitingBuff, 0f);
}
if (motor.jumpCount == 0 && broadcastedUsage)
{
broadcastedUsage = false;
}
}
private bool ReachedMaxJumpCount()
{
return motor.jumpCount >= base.body.maxJumpCount && base.body.maxJumpCount > 0;
}
private bool IsAuthority()
{
return NetworkClient.active && base.body.hasEffectiveAuthority;
}
public void DontConsume()
{
if (IsAuthority() && base.body.maxJumpCount > 0)
{
dontConsumeBonus = true;
prevJumpCount = base.body.maxJumpCount;
timeSinceLastChanged = 0f;
}
}
}
public class BonusJumpContent : IContentPackProvider
{
public static class Buffs
{
public static BuffDef JumpAvailable;
public static BuffDef JumpWaiting;
public static BuffDef JumpCooldown;
public static List<BuffDef> buffDefs = new List<BuffDef>();
public static void Create()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
JumpAvailable = ScriptableObject.CreateInstance<BuffDef>();
((Object)JumpAvailable).name = "BonusJumpAvailable";
JumpAvailable.buffColor = new Color(0.35f, 0.65f, 0.35f);
JumpAvailable.canStack = false;
JumpAvailable.isDebuff = false;
JumpAvailable.iconSprite = Sprites.BonusJumpNormal;
buffDefs.Add(JumpAvailable);
JumpWaiting = ScriptableObject.CreateInstance<BuffDef>();
((Object)JumpWaiting).name = "BonusJumpWaiting";
JumpWaiting.buffColor = new Color(0.65f, 0.65f, 0.35f);
JumpWaiting.canStack = false;
JumpWaiting.isDebuff = false;
JumpWaiting.iconSprite = Sprites.BonusJumpShaded;
buffDefs.Add(JumpWaiting);
JumpCooldown = ScriptableObject.CreateInstance<BuffDef>();
((Object)JumpCooldown).name = "BonusJumpCooldown";
JumpCooldown.buffColor = new Color(0.65f, 0.35f, 0.35f);
JumpCooldown.canStack = true;
JumpCooldown.isDebuff = false;
JumpCooldown.iconSprite = Sprites.BonusJumpShaded;
buffDefs.Add(JumpCooldown);
}
}
public static class Sprites
{
public static Sprite BonusJumpNormal;
public static Sprite BonusJumpShaded;
public static void Create()
{
BonusJumpNormal = BonusJumpPlugin.Assets.LoadAsset<Sprite>("Assets/Icons/texBuffJump.png");
BonusJumpShaded = BonusJumpPlugin.Assets.LoadAsset<Sprite>("Assets/Icons/texBuffJumpShaded.png");
}
}
public ContentPack contentPack = new ContentPack();
public string identifier => "BonusJumpContent";
public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
{
BonusJumpPlugin.LoadAssets();
Sprites.Create();
Buffs.Create();
SetInternalRef();
contentPack.buffDefs.Add(Buffs.buffDefs.ToArray());
args.ReportProgress(1f);
yield break;
}
public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
{
ContentPack.Copy(contentPack, args.output);
args.ReportProgress(1f);
yield break;
}
public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
{
args.ReportProgress(1f);
yield break;
}
public static void SetInternalRef()
{
BonusJumpPlugin.availableBuff = Buffs.JumpAvailable;
BonusJumpPlugin.waitingBuff = Buffs.JumpWaiting;
BonusJumpPlugin.cooldownBuff = Buffs.JumpCooldown;
}
}
[BepInPlugin("com.TPDespair.BonusJump", "BonusJump", "1.1.0")]
public class BonusJumpPlugin : BaseUnityPlugin
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static hook_TokenIsRegistered <>9__30_0;
public static hook_GetString_string <>9__30_1;
public static Func<Instruction, bool> <>9__34_1;
public static Func<Instruction, bool> <>9__34_2;
public static Func<Instruction, bool> <>9__34_3;
public static Func<CharacterBody, int, int> <>9__34_5;
public static Manipulator <>9__34_0;
public static hook_Init <>9__35_0;
public static hook_CleanseBody <>9__38_0;
public static hook_AddTimedBuff_BuffIndex_float <>9__39_0;
public static Func<Instruction, bool> <>9__42_0;
public static Func<Instruction, bool> <>9__42_1;
public static Action<EntityState> <>9__42_2;
internal bool <LanguageOverride>b__30_0(orig_TokenIsRegistered orig, Language self, string token)
{
if (token != null && LangTokens.ContainsKey(token))
{
return true;
}
return orig.Invoke(self, token);
}
internal string <LanguageOverride>b__30_1(orig_GetString_string orig, string token)
{
if (token != null && LangTokens.ContainsKey(token))
{
return LangTokens[token];
}
return orig.Invoke(token);
}
internal void <JumpCountHook>b__34_0(ILContext il)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
<>c__DisplayClass34_0 CS$<>8__locals0 = new <>c__DisplayClass34_0();
ILCursor val = new ILCursor(il);
CS$<>8__locals0.index = -1;
if (val.TryGotoNext(new Func<Instruction, bool>[4]
{
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
(Instruction x) => ILPatternMatchingExt.MatchLdfld<CharacterBody>(x, "baseJumpCount"),
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref CS$<>8__locals0.index)
}))
{
val.Emit(OpCodes.Ldarg, 0);
val.Emit(OpCodes.Ldloc, CS$<>8__locals0.index);
val.EmitDelegate<Func<CharacterBody, int, int>>((Func<CharacterBody, int, int>)delegate(CharacterBody self, int value)
{
if (self.HasBuff(BonusJumpContent.Buffs.JumpAvailable) || self.HasBuff(BonusJumpContent.Buffs.JumpWaiting))
{
value++;
}
return value;
});
val.Emit(OpCodes.Stloc, CS$<>8__locals0.index);
}
else
{
LogWarn("JumpCountHook Failed");
}
}
internal bool <JumpCountHook>b__34_1(Instruction x)
{
return ILPatternMatchingExt.MatchLdarg(x, 0);
}
internal bool <JumpCountHook>b__34_2(Instruction x)
{
return ILPatternMatchingExt.MatchLdarg(x, 0);
}
internal bool <JumpCountHook>b__34_3(Instruction x)
{
return ILPatternMatchingExt.MatchLdfld<CharacterBody>(x, "baseJumpCount");
}
internal int <JumpCountHook>b__34_5(CharacterBody self, int value)
{
if (self.HasBuff(BonusJumpContent.Buffs.JumpAvailable) || self.HasBuff(BonusJumpContent.Buffs.JumpWaiting))
{
value++;
}
return value;
}
internal void <IndicatorBuffDisplayHook>b__35_0(orig_Init orig)
{
orig.Invoke();
HoistIndicatorBuffs();
}
internal void <HandleCleanseHook>b__38_0(orig_CleanseBody orig, CharacterBody body, bool debuff, bool buff, bool cooldown, bool dot, bool stun, bool proj)
{
if (Object.op_Implicit((Object)(object)body) && cooldown)
{
ServerBonusJumpBehavior component = ((Component)body).GetComponent<ServerBonusJumpBehavior>();
if (Object.op_Implicit((Object)(object)component))
{
component.CleanseCooldown();
}
}
orig.Invoke(body, debuff, buff, cooldown, dot, stun, proj);
}
internal void <UsageRequestedHook>b__39_0(orig_AddTimedBuff_BuffIndex_float orig, CharacterBody body, BuffIndex buff, float duration)
{
//IL_0001: 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_0031: Unknown result type (might be due to invalid IL or missing references)
if (buff == waitingBuff.buffIndex)
{
ServerBonusJumpBehavior component = ((Component)body).GetComponent<ServerBonusJumpBehavior>();
if (Object.op_Implicit((Object)(object)component))
{
component.ApplyUsageRequest();
}
}
else
{
orig.Invoke(body, buff, duration);
}
}
internal bool <PaladinAirSlamHook>b__42_0(Instruction x)
{
return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_maxJumpCount");
}
internal bool <PaladinAirSlamHook>b__42_1(Instruction x)
{
return ILPatternMatchingExt.MatchStfld<CharacterMotor>(x, "jumpCount");
}
internal void <PaladinAirSlamHook>b__42_2(EntityState entityState)
{
CharacterMotor characterMotor = entityState.characterMotor;
CharacterBody characterBody = entityState.characterBody;
if (characterMotor.jumpCount < characterBody.maxJumpCount)
{
AuthBonusJumpBehavior component = ((Component)characterBody).GetComponent<AuthBonusJumpBehavior>();
if (Object.op_Implicit((Object)(object)component))
{
component.DontConsume();
}
}
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass34_0
{
public int index;
internal bool <JumpCountHook>b__4(Instruction x)
{
return ILPatternMatchingExt.MatchLdloc(x, ref index);
}
}
public const string ModVer = "1.1.0";
public const string ModName = "BonusJump";
public const string ModGuid = "com.TPDespair.BonusJump";
public static ConfigFile configFile;
public static ManualLogSource logSource;
public static AssetBundle Assets;
public static Dictionary<string, string> LangTokens = new Dictionary<string, string>();
private static readonly BindingFlags Flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
public static BuffDef availableBuff;
public static BuffDef waitingBuff;
public static BuffDef cooldownBuff;
public static ItemIndex RainbowCloudItem = (ItemIndex)(-1);
public static ConfigEntry<float> JumpCooldown { get; set; }
public static ConfigEntry<float> GroundThreshold { get; set; }
public static ConfigEntry<float> CloudCompat { get; set; }
public void Awake()
{
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Expected O, but got Unknown
RoR2Application.isModded = true;
NetworkModCompatibilityHelper.networkModList = NetworkModCompatibilityHelper.networkModList.Append("com.TPDespair.BonusJump:1.1.0");
configFile = ((BaseUnityPlugin)this).Config;
logSource = ((BaseUnityPlugin)this).Logger;
SetupConfig();
LanguageOverride();
if (CloudCompat.Value > 0f)
{
float num = CloudCompat.Value * 100f;
RegisterToken("ITEM_MYSTICSBADITEMS_RAINBOWTRAIL_DESC", "Gain <style=cIsUtility>" + num + "%</style> <style=cStack>(+" + num + "% per stack)</style> <style=cIsUtility>cooldown reduction</style> towards <style=cIsUtility>bonus jump</style>.\nLeave a <link=\"MysticsBadItemsRainbowWavy\">rainbow trail</link> behind.");
RegisterToken("ITEM_MYSTICSBADITEMS_RAINBOWTRAIL_PICKUP", "Gain bonus jump cooldown recovery and leave a <link=\"MysticsBadItemsRainbowWavy\">rainbow trail</link> behind.");
}
ContentManager.collectContentPackProviders += new CollectContentPackProvidersDelegate(ContentManager_collectContentPackProviders);
JumpCountHook();
IndicatorBuffDisplayHook();
CharacterBody.onBodyInventoryChangedGlobal += HandleItemBehavior;
HandleCleanseHook();
UsageRequestedHook();
RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(LateSetup));
}
private static void LateSetup()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
AllocateBehaviorBuffs();
if (PluginLoaded("com.themysticsword.mysticsbaditems"))
{
RainbowCloudItem = FindItemIndex("MysticsBadItems_RainbowTrail");
}
PaladinCompat();
}
private static ItemIndex FindItemIndex(string itemName)
{
//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_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Invalid comparison between Unknown and I4
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
ItemIndex val = ItemCatalog.FindItemIndex(itemName);
if ((int)val == -1)
{
LogWarn("Could not find ItemIndex for : " + itemName);
}
return val;
}
private static void SetupConfig()
{
JumpCooldown = configFile.Bind<float>("General", "JumpCooldown", 10f, "Cooldown of bonus jump. Cooldown only recovers while grounded.");
GroundThreshold = configFile.Bind<float>("General", "GroundThreshold", 0.25f, "Time after not being grounded to still be counted as grounded for cooldown recovery.");
CloudCompat = configFile.Bind<float>("General", "CloudCompat", 0.25f, "Bonus jump cooldown reduction per Cloud Nine. Set to 0 to disable.");
}
private void ContentManager_collectContentPackProviders(AddContentPackProviderDelegate addContentPackProvider)
{
addContentPackProvider.Invoke((IContentPackProvider)(object)new BonusJumpContent());
}
internal static void LoadAssets()
{
using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("TPDespair.BonusJump.bonusjumpbundle");
Assets = AssetBundle.LoadFromStream(stream);
}
private static void LanguageOverride()
{
//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_0020: Expected O, but got Unknown
//IL_003a: 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_0045: Expected O, but got Unknown
object obj = <>c.<>9__30_0;
if (obj == null)
{
hook_TokenIsRegistered val = (orig_TokenIsRegistered orig, Language self, string token) => (token != null && LangTokens.ContainsKey(token)) || orig.Invoke(self, token);
<>c.<>9__30_0 = val;
obj = (object)val;
}
Language.TokenIsRegistered += (hook_TokenIsRegistered)obj;
object obj2 = <>c.<>9__30_1;
if (obj2 == null)
{
hook_GetString_string val2 = (orig_GetString_string orig, string token) => (token != null && LangTokens.ContainsKey(token)) ? LangTokens[token] : orig.Invoke(token);
<>c.<>9__30_1 = val2;
obj2 = (object)val2;
}
Language.GetString_string += (hook_GetString_string)obj2;
}
public static void RegisterToken(string token, string text)
{
if (!LangTokens.ContainsKey(token))
{
LangTokens.Add(token, text);
}
else
{
LangTokens[token] = text;
}
}
internal static void LogWarn(object data)
{
logSource.LogWarning(data);
}
internal static bool PluginLoaded(string key)
{
return Chainloader.PluginInfos.ContainsKey(key);
}
private static void JumpCountHook()
{
//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_0020: Expected O, but got Unknown
object obj = <>c.<>9__34_0;
if (obj == null)
{
Manipulator val = delegate(ILContext il)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
ILCursor val2 = new ILCursor(il);
int index = -1;
if (val2.TryGotoNext(new Func<Instruction, bool>[4]
{
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
(Instruction x) => ILPatternMatchingExt.MatchLdfld<CharacterBody>(x, "baseJumpCount"),
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref index)
}))
{
val2.Emit(OpCodes.Ldarg, 0);
val2.Emit(OpCodes.Ldloc, index);
val2.EmitDelegate<Func<CharacterBody, int, int>>((Func<CharacterBody, int, int>)delegate(CharacterBody self, int value)
{
if (self.HasBuff(BonusJumpContent.Buffs.JumpAvailable) || self.HasBuff(BonusJumpContent.Buffs.JumpWaiting))
{
value++;
}
return value;
});
val2.Emit(OpCodes.Stloc, index);
}
else
{
LogWarn("JumpCountHook Failed");
}
};
<>c.<>9__34_0 = val;
obj = (object)val;
}
CharacterBody.RecalculateStats += (Manipulator)obj;
}
private static void IndicatorBuffDisplayHook()
{
//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_0020: Expected O, but got Unknown
object obj = <>c.<>9__35_0;
if (obj == null)
{
hook_Init val = delegate(orig_Init orig)
{
orig.Invoke();
HoistIndicatorBuffs();
};
<>c.<>9__35_0 = val;
obj = (object)val;
}
BuffCatalog.Init += (hook_Init)obj;
}
private static void HoistIndicatorBuffs()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: 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_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Expected I4, but got Unknown
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Expected I4, but got Unknown
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected I4, but got Unknown
BuffIndex jumpAvailable = availableBuff.buffIndex;
BuffIndex jumpWaiting = waitingBuff.buffIndex;
BuffIndex jumpCooldown = cooldownBuff.buffIndex;
BuffIndex[] collection = (BuffIndex[])(object)new BuffIndex[3]
{
(BuffIndex)(int)jumpAvailable,
(BuffIndex)(int)jumpWaiting,
(BuffIndex)(int)jumpCooldown
};
List<BuffIndex> list = new List<BuffIndex>(BuffCatalog.nonHiddenBuffIndices);
list.RemoveAll((BuffIndex t) => t == jumpAvailable || t == jumpWaiting || t == jumpCooldown);
List<BuffIndex> list2 = new List<BuffIndex>();
list2.AddRange(collection);
list2.AddRange(list);
BuffCatalog.nonHiddenBuffIndices = list2.ToArray();
}
private static void HandleItemBehavior(CharacterBody body)
{
int num = (body.isPlayerControlled ? 1 : 0);
body.AddItemBehavior<AuthBonusJumpBehavior>(num);
if (NetworkServer.active)
{
body.AddItemBehavior<ServerBonusJumpBehavior>(num);
}
}
private static void HandleCleanseHook()
{
//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_0020: Expected O, but got Unknown
object obj = <>c.<>9__38_0;
if (obj == null)
{
hook_CleanseBody val = delegate(orig_CleanseBody orig, CharacterBody body, bool debuff, bool buff, bool cooldown, bool dot, bool stun, bool proj)
{
if (Object.op_Implicit((Object)(object)body) && cooldown)
{
ServerBonusJumpBehavior component = ((Component)body).GetComponent<ServerBonusJumpBehavior>();
if (Object.op_Implicit((Object)(object)component))
{
component.CleanseCooldown();
}
}
orig.Invoke(body, debuff, buff, cooldown, dot, stun, proj);
};
<>c.<>9__38_0 = val;
obj = (object)val;
}
Util.CleanseBody += (hook_CleanseBody)obj;
}
private static void UsageRequestedHook()
{
//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_0020: Expected O, but got Unknown
object obj = <>c.<>9__39_0;
if (obj == null)
{
hook_AddTimedBuff_BuffIndex_float val = delegate(orig_AddTimedBuff_BuffIndex_float orig, CharacterBody body, BuffIndex buff, float duration)
{
//IL_0001: 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_0031: Unknown result type (might be due to invalid IL or missing references)
if (buff == waitingBuff.buffIndex)
{
ServerBonusJumpBehavior component = ((Component)body).GetComponent<ServerBonusJumpBehavior>();
if (Object.op_Implicit((Object)(object)component))
{
component.ApplyUsageRequest();
}
}
else
{
orig.Invoke(body, buff, duration);
}
};
<>c.<>9__39_0 = val;
obj = (object)val;
}
CharacterBody.AddTimedBuff_BuffIndex_float += (hook_AddTimedBuff_BuffIndex_float)obj;
}
private static void AllocateBehaviorBuffs()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: 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)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
ServerBonusJumpBehavior.availableBuff = availableBuff.buffIndex;
ServerBonusJumpBehavior.waitingBuff = waitingBuff.buffIndex;
ServerBonusJumpBehavior.cooldownBuff = cooldownBuff.buffIndex;
AuthBonusJumpBehavior.availableBuff = availableBuff.buffIndex;
AuthBonusJumpBehavior.waitingBuff = waitingBuff.buffIndex;
}
private static void PaladinCompat()
{
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Expected O, but got Unknown
if (!PluginLoaded("com.rob.Paladin"))
{
return;
}
BaseUnityPlugin instance = Chainloader.PluginInfos["com.rob.Paladin"].Instance;
Assembly assembly = Assembly.GetAssembly(((object)instance).GetType());
Type type = Type.GetType("PaladinMod.States.AirSlam, " + assembly.FullName, throwOnError: false);
if (type != null)
{
MethodInfo method = type.GetMethod("OnEnter", Flags);
if (method != null)
{
HookEndpointManager.Modify((MethodBase)method, (Delegate)new Manipulator(PaladinAirSlamHook));
}
else
{
LogWarn("[PaladinAirSlam] - Could Not Find Method : AirSlam.OnEnter");
}
}
else
{
LogWarn("[PaladinAirSlam] - Could Not Find Type : PaladinMod.States.AirSlam");
}
}
private static void PaladinAirSlamHook(ILContext il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (val.TryGotoNext(new Func<Instruction, bool>[2]
{
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_maxJumpCount"),
(Instruction x) => ILPatternMatchingExt.MatchStfld<CharacterMotor>(x, "jumpCount")
}))
{
val.Emit(OpCodes.Ldarg, 0);
val.EmitDelegate<Action<EntityState>>((Action<EntityState>)delegate(EntityState entityState)
{
CharacterMotor characterMotor = entityState.characterMotor;
CharacterBody characterBody = entityState.characterBody;
if (characterMotor.jumpCount < characterBody.maxJumpCount)
{
AuthBonusJumpBehavior component = ((Component)characterBody).GetComponent<AuthBonusJumpBehavior>();
if (Object.op_Implicit((Object)(object)component))
{
component.DontConsume();
}
}
});
}
else
{
LogWarn("PaladinAirSlamHook Failed");
}
}
}
