using System;
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 BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Reptile;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyCompany("LedgeGrab")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("My first plugin")]
[assembly: AssemblyTitle("LedgeGrab")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace LedgeGrab
{
public static class AnimationUtility
{
public static int GetAnimationByName(string name)
{
if (BunchOfEmotesSupport.Installed && BunchOfEmotesSupport.TryGetGameAnimationForCustomAnimation(name, out var gameAnim))
{
return gameAnim;
}
return Animator.StringToHash(name);
}
}
public static class BunchOfEmotesSupport
{
private static object BoEPluginInstance = null;
private static Type BoEPluginType = null;
private static FieldInfo CustomAnimsField = null;
private static bool Cached = false;
private static Dictionary<string, int> GameAnimationByCustomAnimation = new Dictionary<string, int>();
public static bool Installed { get; private set; } = false;
public static void Initialize()
{
Installed = true;
BoEPluginInstance = Chainloader.PluginInfos["com.Dragsun.BunchOfEmotes"].Instance;
BoEPluginType = ReflectionUtility.GetTypeByName("BunchOfEmotes.BunchOfEmotesPlugin");
CustomAnimsField = BoEPluginType.GetField("myCustomAnims2");
}
public static void CacheAnimationsIfNecessary()
{
if (Cached || !(CustomAnimsField.GetValue(BoEPluginInstance) is Dictionary<int, string> dictionary) || dictionary.Count <= 0)
{
return;
}
Cached = true;
foreach (KeyValuePair<int, string> item in dictionary)
{
int key = item.Key;
GameAnimationByCustomAnimation[item.Value] = key;
}
}
public static bool TryGetGameAnimationForCustomAnimation(string customAnim, out int gameAnim)
{
if (!Installed)
{
gameAnim = 0;
return false;
}
CacheAnimationsIfNecessary();
if (GameAnimationByCustomAnimation.TryGetValue(customAnim, out gameAnim))
{
return true;
}
return false;
}
}
[HarmonyPatch(typeof(LedgeClimbAbility))]
internal class LedgeClimbAbilityPatches
{
public static float currentSpeed = 0f;
public static Queue<Vector3> currentSpeeds = new Queue<Vector3>();
public static bool LedgeClimbing = false;
[HarmonyPrefix]
[HarmonyPatch("CheckActivation")]
public static bool CheckActivationPatch(LedgeClimbAbility __instance, ref bool __result)
{
//IL_000c: 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)
currentSpeeds.Enqueue(((Ability)__instance).p.GetVelocity());
if (currentSpeeds.Count > 5)
{
currentSpeeds.Dequeue();
}
if (Settings.ActionPressed(Settings.PumaClimbActions))
{
LedgeClimbing = true;
}
return true;
}
[HarmonyPostfix]
[HarmonyPatch("OnStopAbility")]
public static void OnStopPatch(LedgeClimbAbility __instance)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: 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_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
((Ability)__instance).p.anim.speed = 1f;
__instance.state = (State)2;
bool ledgeClimbing = LedgeClimbing;
float value = Settings.horizontalToVerticalPercent.Value;
float value2 = Settings.horizontalToVerticalMax.Value;
float value3 = Settings.horizontalLossPercent.Value;
float value4 = Settings.minReferenceSpeed.Value;
float value5 = Settings.minForwardSpeed.Value;
float value6 = Settings.finalMulti.Value;
if (ledgeClimbing)
{
Vector3 val = currentSpeeds.Dequeue();
if (Settings.ActionPressed(Settings.PumaClimbActions))
{
((Ability)__instance).p.DoTrick((TrickType)9, "Puma Climb", 0);
Vector3 val2 = default(Vector3);
((Vector3)(ref val2))..ctor(val.x, 0f, val.z);
float num = ((Vector3)(ref val2)).magnitude;
float y = val.y;
y += Settings.PumaClimb.Value;
if (num < value5)
{
num = value5;
}
float num2 = num * value;
num2 = Mathf.Min(num2, value2);
float num3 = num2 * Mathf.Clamp01(value3);
Vector3 val3 = ((Vector3)(ref val2)).normalized * Mathf.Max(0f, num - num3);
y += num2;
y *= value6;
Vector3 velocity = val3 + Vector3.up * y;
((Ability)__instance).p.SetVelocity(velocity);
((Ability)__instance).p.AudioManager.PlaySfxGameplay((SfxCollectionID)20, (AudioClipID)130, ((Ability)__instance).p.playerOneShotAudioSource, 0f);
((Ability)__instance).p.PlayVoice((AudioClipID)489, (VoicePriority)0, true);
((Ability)__instance).p.DoHighJumpEffects(((Ability)__instance).p.motor.groundNormalVisual * -1f);
}
}
LedgeClimbing = false;
}
[HarmonyPrefix]
[HarmonyPatch("FixedUpdateAbility")]
public static bool FixedUpdateAbilityPatch(LedgeClimbAbility __instance)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Invalid comparison between Unknown and I4
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Invalid comparison between Unknown and I4
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Invalid comparison between Unknown and I4
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Invalid comparison between Unknown and I4
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Invalid comparison between Unknown and I4
//IL_027b: Unknown result type (might be due to invalid IL or missing references)
//IL_0281: Invalid comparison between Unknown and I4
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Invalid comparison between Unknown and I4
//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
//IL_02c9: Invalid comparison between Unknown and I4
//IL_0305: Unknown result type (might be due to invalid IL or missing references)
//IL_030b: Invalid comparison between Unknown and I4
//IL_0469: Unknown result type (might be due to invalid IL or missing references)
//IL_046e: Unknown result type (might be due to invalid IL or missing references)
//IL_0472: Unknown result type (might be due to invalid IL or missing references)
//IL_0478: Invalid comparison between Unknown and I4
//IL_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Invalid comparison between Unknown and I4
//IL_021b: Unknown result type (might be due to invalid IL or missing references)
//IL_0220: Unknown result type (might be due to invalid IL or missing references)
//IL_023c: Unknown result type (might be due to invalid IL or missing references)
//IL_0241: Unknown result type (might be due to invalid IL or missing references)
//IL_035c: Unknown result type (might be due to invalid IL or missing references)
//IL_0362: Invalid comparison between Unknown and I4
//IL_0399: Unknown result type (might be due to invalid IL or missing references)
//IL_039f: Invalid comparison between Unknown and I4
//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
//IL_03dc: Invalid comparison between Unknown and I4
//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Invalid comparison between Unknown and I4
//IL_0410: Unknown result type (might be due to invalid IL or missing references)
//IL_0416: Invalid comparison between Unknown and I4
//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
string value = Settings.ledgegrabCfg.Value;
string value2 = Settings.ledgegrabInlineCfg.Value;
string value3 = Settings.ledgegrabSkateboardCfg.Value;
string value4 = Settings.ledgegrabBMXCfg.Value;
if ((int)((Ability)__instance).p.moveStyle == 0)
{
__instance.vaultSlideHash = AnimationUtility.GetAnimationByName(value);
}
else if ((int)((Ability)__instance).p.moveStyle == 3)
{
__instance.vaultSlideHash = AnimationUtility.GetAnimationByName(value2);
}
else if ((int)((Ability)__instance).p.moveStyle == 2)
{
__instance.vaultSlideHash = AnimationUtility.GetAnimationByName(value3);
}
else if ((int)((Ability)__instance).p.moveStyle == 1)
{
__instance.vaultSlideHash = AnimationUtility.GetAnimationByName(value4);
}
else
{
__instance.vaultSlideHash = Animator.StringToHash("vaultSlide");
}
Player p = ((Ability)__instance).p;
WorldHandler instance = WorldHandler.instance;
if ((Object)(object)p != (Object)(object)((instance != null) ? instance.GetCurrentPlayer() : null))
{
return true;
}
float value5 = Settings.LedgeGrabDelay.Value;
bool flag = ((Ability)__instance).p.abilityTimer > value5;
if ((int)__instance.state == 1)
{
if (Settings.PauseAnimationInline.Value && (int)((Ability)__instance).p.moveStyle == 3)
{
((Ability)__instance).p.anim.speed = 0f;
}
else if (Settings.PauseAnimationSkateboard.Value && (int)((Ability)__instance).p.moveStyle == 2)
{
((Ability)__instance).p.anim.speed = 0f;
}
else if (Settings.PauseAnimationBMX.Value && (int)((Ability)__instance).p.moveStyle == 1)
{
((Ability)__instance).p.anim.speed = 0f;
}
else if (Settings.PauseAnimation.Value)
{
((Ability)__instance).p.anim.speed = 0f;
}
((Ability)__instance).normalMovement = false;
((Ability)__instance).normalRotation = false;
((Ability)__instance).customVelocity = Vector3.zero;
((Ability)__instance).customGravity = 0f;
((Ability)__instance).customTargetRot = ((Component)((Ability)__instance).p).transform.forward;
}
else
{
((Ability)__instance).p.anim.speed = 1f;
((Ability)__instance).normalMovement = true;
((Ability)__instance).normalRotation = true;
((Ability)__instance).customGravity = -1f;
}
if ((int)__instance.state == 0)
{
if (((Ability)__instance).p.abilityTimer > 0.15f)
{
((Ability)__instance).p.skipLanding = true;
((Ability)__instance).p.StopCurrentAbility();
}
}
else if ((int)__instance.state == 1)
{
if (flag && ((Ability)__instance).p.forwardInput > 0.75f)
{
__instance.SetState((State)2);
}
}
else if ((int)__instance.state == 2)
{
if (true)
{
string value6 = Settings.ledgejumpCfg.Value;
string value7 = Settings.ledgejumpInlineCfg.Value;
string value8 = Settings.ledgejumpSkateboardCfg.Value;
string value9 = Settings.ledgejumpBMXCfg.Value;
if ((int)((Ability)__instance).p.moveStyle == 0)
{
((Ability)__instance).p.PlayAnim(AnimationUtility.GetAnimationByName(Settings.ledgejumpCfg.Value), false, false, -1f);
}
else if ((int)((Ability)__instance).p.moveStyle == 3)
{
((Ability)__instance).p.PlayAnim(AnimationUtility.GetAnimationByName(Settings.ledgejumpInlineCfg.Value), false, false, -1f);
}
else if ((int)((Ability)__instance).p.moveStyle == 2)
{
((Ability)__instance).p.PlayAnim(AnimationUtility.GetAnimationByName(Settings.ledgejumpSkateboardCfg.Value), false, false, -1f);
}
else if ((int)((Ability)__instance).p.moveStyle == 1)
{
((Ability)__instance).p.PlayAnim(AnimationUtility.GetAnimationByName(Settings.ledgejumpBMXCfg.Value), false, false, -1f);
}
else
{
((Ability)__instance).p.PlayAnim(Animator.StringToHash("jump"), false, false, -1f);
}
}
}
else
{
State state = __instance.state;
}
if ((int)__instance.state != 1 && !((Ability)__instance).p.IsGrounded())
{
((Ability)__instance).p.StopCurrentAbility();
return false;
}
if (flag && ((Ability)__instance).p.AnyTrickInput())
{
((Ability)__instance).p.StopCurrentAbility();
Transform tf = ((Ability)__instance).p.tf;
tf.position += ((Ability)__instance).p.tf.forward * -1f;
}
else if (((Ability)__instance).p.abilityTimer > 10f && ((Ability)__instance).p.slideButtonHeld && !((Ability)((Ability)__instance).p.slideAbility).locked)
{
((Ability)__instance).p.ActivateAbility((Ability)(object)((Ability)__instance).p.slideAbility);
return false;
}
if (((Ability)__instance).p.curAnim != __instance.vaultSlideHash)
{
((Ability)__instance).p.StopCurrentAbility();
}
if (((Ability)__instance).p.CheckBoostTrick() && ((Ability)__instance).p.AnyTrickInput())
{
((Ability)__instance).p.Jump();
((Ability)__instance).p.ActivateAbility((Ability)(object)((Ability)__instance).p.groundTrickAbility);
}
((Ability)__instance).p.SetVisualRotLocal0();
return false;
}
[HarmonyPostfix]
[HarmonyPatch("Init")]
public static void InitPatch(LedgeClimbAbility __instance)
{
__instance.climbableHeightFromPos = Settings.LedgeGrabDistance.Value;
}
}
[BepInPlugin("fay.LedgeGrab", "Ledge Grab", "1.0.0")]
[BepInProcess("Bomb Rush Cyberfunk.exe")]
public class Plugin : BaseUnityPlugin
{
public static ManualLogSource Logger;
internal static Harmony Harmony = new Harmony("fay.LedgeGrab");
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Logger.LogInfo((object)"FAY WAS HERE :3 :3 :3 :3 :3 :3 :3 :3");
Logger.LogInfo((object)"FROM TEAM SPRINGBOARD WITH LOVE <3");
Logger.LogInfo((object)"weeeeeeeeeeeeeeeeeeeeeeeeeee");
Harmony.PatchAll();
Settings.BindSettings(((BaseUnityPlugin)this).Config);
if (Chainloader.PluginInfos.ContainsKey("com.Dragsun.BunchOfEmotes"))
{
BunchOfEmotesSupport.Initialize();
}
}
private void OnDestroy()
{
Harmony.UnpatchSelf();
}
}
public static class ReflectionUtility
{
public static Type GetTypeByName(string name)
{
foreach (Assembly item in AppDomain.CurrentDomain.GetAssemblies().Reverse())
{
Type type = item.GetType(name);
if (type != null)
{
return type;
}
}
return null;
}
}
internal class Settings
{
public static ConfigEntry<float> PumaClimb;
private static ConfigEntry<string> PumaClimbInputs;
public static ConfigEntry<string> ledgegrabCfg;
public static ConfigEntry<string> ledgegrabInlineCfg;
public static ConfigEntry<string> ledgegrabSkateboardCfg;
public static ConfigEntry<string> ledgegrabBMXCfg;
public static ConfigEntry<string> ledgejumpCfg;
public static ConfigEntry<string> ledgejumpInlineCfg;
public static ConfigEntry<string> ledgejumpSkateboardCfg;
public static ConfigEntry<string> ledgejumpBMXCfg;
public static List<string> PumaClimbActions;
public static ConfigEntry<float> LedgeGrabDistance;
public static ConfigEntry<float> LedgeGrabDelay;
public static ConfigEntry<bool> PauseAnimation;
public static ConfigEntry<bool> PauseAnimationInline;
public static ConfigEntry<bool> PauseAnimationSkateboard;
public static ConfigEntry<bool> PauseAnimationBMX;
public static ConfigEntry<float> horizontalToVerticalPercent;
public static ConfigEntry<float> horizontalToVerticalMax;
public static ConfigEntry<float> horizontalLossPercent;
public static ConfigEntry<float> minReferenceSpeed;
public static ConfigEntry<float> minForwardSpeed;
public static ConfigEntry<float> finalMulti;
public static void BindSettings(ConfigFile Config)
{
//IL_020a: Unknown result type (might be due to invalid IL or missing references)
//IL_0214: Expected O, but got Unknown
//IL_0261: Unknown result type (might be due to invalid IL or missing references)
//IL_026b: Expected O, but got Unknown
//IL_0299: Unknown result type (might be due to invalid IL or missing references)
//IL_02a3: Expected O, but got Unknown
PumaClimb = Config.Bind<float>("Puma Climb", "Puma Climb Amount", 8f, "How much speed is added when triggering a Puma Climb");
PumaClimbInputs = Config.Bind<string>("Puma Climb", "Puma Climb Inputs", "slide", "What actions to press to trigger a Puma Climb (acceptable values: slide, boost, spray, dance, trick1, trick2, trick3, trickAny, switchStyle, walk)");
LedgeGrabDistance = Config.Bind<float>("Ledge Grab", "Ledge Grab Distance", 2f, "The minimum required distance to grab a ledge (Vanilla value is 1.1)");
LedgeGrabDelay = Config.Bind<float>("Ledge Grab", "Ledge Grab Delay", 0.35f, "How long it will take holding forward to climb a ledge");
ledgegrabCfg = Config.Bind<string>("Ledge Grab", "On Foot Ledge Grab Animation", "vaultSlide", "On Foot Ledge Grab Animation");
ledgegrabInlineCfg = Config.Bind<string>("Ledge Grab", "Inline Ledge Grab Animation", "vaultSlide", "On Foot Ledge Grab Animation");
ledgegrabSkateboardCfg = Config.Bind<string>("Ledge Grab", "Skateboard Ledge Grab Animation", "vaultSlide", "On Foot Ledge Grab Animation");
ledgegrabBMXCfg = Config.Bind<string>("Ledge Grab", "BMX Ledge Grab Animation", "vaultSlide", "On Foot Ledge Grab Animation");
ledgejumpCfg = Config.Bind<string>("Ledge Jump", "On Foot Ledge Jump Animation", "jump", "On Foot Ledge Jump Animation");
ledgejumpInlineCfg = Config.Bind<string>("Ledge Jump", "Inline Ledge Jump Animation", "jump", "On Foot Ledge Jump Animation");
ledgejumpSkateboardCfg = Config.Bind<string>("Ledge Jump", "Skateboard Ledge Jump Animation", "jump", "On Foot Ledge Jump Animation");
ledgejumpBMXCfg = Config.Bind<string>("Ledge Jump", "BMX Ledge Jump Animation", "jump", "On Foot Ledge Jump Animation");
PauseAnimation = Config.Bind<bool>("Ledge Grab", "Pause Animation", false, "Allows pausing animation when grabbing ledge");
PauseAnimationInline = Config.Bind<bool>("Ledge Grab", "Pause Animation Inline", true, "Allows pausing animation when grabbing ledge");
PauseAnimationSkateboard = Config.Bind<bool>("Ledge Grab", "Pause Animation Skateboard", true, "Allows pausing animation when grabbing ledge");
PauseAnimationBMX = Config.Bind<bool>("Ledge Grab", "Pause Animation BMX", true, "Allows pausing animation when grabbing ledge");
horizontalToVerticalMax = Config.Bind<float>("Puma Climb", "horizontalToVerticalMax", 500000f, new ConfigDescription("Max speed taken from horizontal and given to vertical in Puma Climb. 10 is equivalent to 100 on Dragsun's speedometer, just move the decimal one over to the left.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, float.MaxValue), Array.Empty<object>()));
minReferenceSpeed = Config.Bind<float>("Puma Climb", "minReferenceSpeed", 0f, "Speed at which to begin converting horizontal to vertical in Puma Climb");
horizontalToVerticalPercent = Config.Bind<float>("Puma Climb", "Horizontal To Vertical Percent", 1f, new ConfigDescription("What percentage of horizontal speed to convert to vertical in Puma Climb", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
horizontalLossPercent = Config.Bind<float>("Puma Climb", "horizontalLossPercent", 1f, new ConfigDescription("What percentage of horizontal speed is actually lost when transfering to vertical in Puma Climb", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
minForwardSpeed = Config.Bind<float>("Puma Climb", "minForwardSpeed", 0f, "Minimum forward speed given from Puma Climb");
finalMulti = Config.Bind<float>("Puma Climb", "finalMulti", 0.6f, "Final vertical speed multiplier for Puma Climb");
PumaClimbInputs.SettingChanged += UpdateSettingsEvent;
CreateActionLists();
}
public static void UpdateSettingsEvent(object sender, EventArgs args)
{
CreateActionLists();
}
public static void CreateActionLists()
{
PumaClimbActions = ConvertConfigStringToList(PumaClimbInputs);
}
private static List<string> ConvertConfigStringToList(ConfigEntry<string> configEntry)
{
List<string> list = new List<string>
{
"jump", "slide", "boost", "spray", "dance", "switchstyle", "trick1", "trick2", "trick3", "trickany",
"walk"
};
List<string> list2 = configEntry.Value.Replace(" ", "").ToLower().Split(new char[1] { ',' })
.ToList();
List<string> list3 = new List<string>();
foreach (string item in list2)
{
string text = item;
if (list.Contains(text))
{
if (!text.Equals("trickany"))
{
text = ((!text.Equals("switchstyle")) ? (text + "ButtonNew") : "switchStyleButtonNew");
}
else
{
text = "trick1ButtonNew";
list3.Add(text);
text = "trick2ButtonNew";
list3.Add(text);
text = "trick3ButtonNew";
}
list3.Add(text);
}
}
return list3;
}
private static bool TranslateActionString(string action)
{
WorldHandler instance = WorldHandler.instance;
Player val = ((instance != null) ? instance.GetCurrentPlayer() : null);
if ((Object)(object)val == (Object)null)
{
return false;
}
if (1 == 0)
{
}
bool result = action switch
{
"jumpButtonNew" => val.jumpButtonHeld || val.jumpButtonNew,
"trick1ButtonNew" => val.trick1ButtonHeld || val.trick1ButtonNew,
"trick2ButtonNew" => val.trick2ButtonHeld || val.trick2ButtonNew,
"trick3ButtonNew" => val.trick3ButtonHeld || val.trick3ButtonNew,
"slideButtonNew" => val.slideButtonHeld || val.slideButtonNew,
"boostButtonNew" => val.boostButtonHeld || val.boostButtonNew,
"sprayButtonNew" => val.sprayButtonHeld || val.sprayButtonNew,
"danceButtonNew" => val.danceButtonHeld || val.danceButtonNew,
"switchStyleButtonNew" => val.switchStyleButtonHeld || val.switchStyleButtonNew,
"walkButtonNew" => val.walkButtonHeld || val.walkButtonNew,
_ => false,
};
if (1 == 0)
{
}
return result;
}
public static bool ActionPressed(List<string> actions)
{
if (actions == null || !actions.Any())
{
return false;
}
foreach (string action in actions)
{
if (TranslateActionString(action))
{
return true;
}
}
return false;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "LedgeGrab";
public const string PLUGIN_NAME = "My first plugin";
public const string PLUGIN_VERSION = "1.0.0";
}
}
