using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using UnityEngine;
using tact_csharp2;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("GameAssembly")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SuperBattleGolf_Haptics")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+726cb261100fb3ff66bc2b2beaa4654feecddd38")]
[assembly: AssemblyProduct("Super Battle Golf bHaptics integration")]
[assembly: AssemblyTitle("SuperBattleGolf_Haptics")]
[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 SBG.Haptics
{
[HarmonyPatch(typeof(MainMenu))]
public class MenuPatches
{
[HarmonyPatch("OnIntroMenuShown")]
[HarmonyPostfix]
public static void Postfix()
{
BhapticsSDK2Wrapper.play("gamestart");
}
}
[HarmonyPatch(typeof(PlayerInfo))]
public class PlayerInfoPatches
{
[HarmonyPatch("UserCode_RpcInformOfBlownAirhorn__PlayerInventory")]
[HarmonyPostfix]
public static void PostfixAirhornAffected()
{
BhapticsSDK2Wrapper.playParam("airhorn", 1, 1f, 1f, 0f, 0f);
}
[HarmonyPatch("UserCode_RpcInformPickedUpItemFromItemSpawner")]
[HarmonyPostfix]
public static void PostfixItemPickup()
{
BhapticsSDK2Wrapper.playParam("lightinteract", 1, 0.75f, 1f, 0f, 0f);
}
}
[HarmonyPatch(typeof(PlayerGolfer))]
public class GolferPatches
{
[HarmonyPatch("UpdateSwingNormalizedPower")]
[HarmonyPostfix]
public static void PostfixOvercharge(PlayerGolfer __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
bool flag = __instance.IsChargingSwing && __instance.SwingNormalizedCharge > 1f;
if (flag && !HapticsPlugin.IsOverchargeLoopPlaying)
{
BhapticsSDK2Wrapper.playLoop("overcharge", 1, 1f, 1f, 0f, 0f, 200, 999999);
HapticsPlugin.IsOverchargeLoopPlaying = true;
}
else if (!flag && HapticsPlugin.IsOverchargeLoopPlaying)
{
BhapticsSDK2Wrapper.stopByEventId("overcharge");
HapticsPlugin.IsOverchargeLoopPlaying = false;
}
}
}
[HarmonyPatch("ClearOverchargedVfx")]
[HarmonyPostfix]
public static void PostfixClearOverchargeVfx(PlayerGolfer __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
StopOvercharge();
}
}
private static void StopOvercharge()
{
if (HapticsPlugin.IsOverchargeLoopPlaying)
{
BhapticsSDK2Wrapper.stopByEventId("overcharge");
HapticsPlugin.IsOverchargeLoopPlaying = false;
}
}
[HarmonyPatch("InformScored")]
[HarmonyPostfix]
public static void PostfixScored(PlayerGolfer __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.playParam("holein", 1, 1f, 2f, 0f, 0f);
}
}
[HarmonyPatch("UserCode_RpcInformWillBeEliminated__EliminationReason__Vector3")]
[HarmonyPostfix]
public static void PostfixEliminated(EliminationReason immediateEliminationReason)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: 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
if (immediateEliminationReason - 24 <= 1)
{
BhapticsSDK2Wrapper.playParam("bigexplode", 0, 1f, 0.5f, 0f, 0f);
}
}
}
[HarmonyPatch(typeof(PlayerInventory))]
public class PlayerInventoryPatches
{
[HarmonyPatch("TrySelectItemSlot")]
[HarmonyPostfix]
public static void PostfixSelectItemSlot(PlayerInventory __instance, bool __result)
{
if (__result)
{
BhapticsSDK2Wrapper.playParam("lightinteract", 1, 0.75f, 1f, 0f, 0f);
}
}
[HarmonyPatch("TryDeselectItem")]
[HarmonyPostfix]
public static void PostfixDeselectItem(PlayerInventory __instance, bool __result)
{
if (__result)
{
BhapticsSDK2Wrapper.playParam("lightinteract", 1, 0.45f, 1f, 0f, 0f);
}
}
[HarmonyPatch("OnActivatedElectromagnet")]
[HarmonyPostfix]
public static void PostfixMagnetActivated(PlayerInventory __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.playParam("magnet", 1, 1f, 0.5f, 0f, 0f);
}
}
[HarmonyPatch("OnActivatedOrbitalLaser")]
[HarmonyPostfix]
public static void PostfixOrbitalLaser(PlayerInventory __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.play("orbitallaseruse");
}
}
}
[HarmonyPatch(typeof(PlayerAudio))]
public class PlayerAudioPatches
{
[HarmonyPatch("PlaySwingHitForAllClients")]
[HarmonyPostfix]
public static void PostfixSwingHit(PlayerAudio __instance, Hittable hitHittable, bool fromRocketDriver)
{
PlayerInfo component = ((Component)__instance).GetComponent<PlayerInfo>();
if (!((Object)(object)component == (Object)null) && ((NetworkBehaviour)component).isLocalPlayer)
{
BhapticsSDK2Wrapper.stopByEventId("overcharge");
HapticsPlugin.IsOverchargeLoopPlaying = false;
PlayerGolfer asGolfer = component.AsGolfer;
if (!((Object)(object)asGolfer == (Object)null))
{
float swingNormalizedPower = asGolfer.SwingNormalizedPower;
BhapticsSDK2Wrapper.playParam("golfhit", 0, swingNormalizedPower, 1f, 0f, 0f);
}
}
}
[HarmonyPatch("PlayElephantGunShotForAllClients")]
[HarmonyPostfix]
public static void PostfixElephantGunShot(PlayerAudio __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.play("elephantgun");
}
}
[HarmonyPatch("PlayPistolShotForAllClients")]
[HarmonyPostfix]
public static void PostfixPistolShot(PlayerAudio __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.play("pistol");
}
}
[HarmonyPatch("PlayFreezeBombShotForAllClients")]
[HarmonyPostfix]
public static void PostfixFreezeBombShot(PlayerAudio __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.play("iceshot");
}
}
[HarmonyPatch("PlayItemUseForAllClients")]
[HarmonyPostfix]
public static void PostfixItemUse(PlayerAudio __instance, ItemType itemType)
{
//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)
//IL_0012: 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_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Invalid comparison between Unknown and I4
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Invalid comparison between Unknown and I4
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Invalid comparison between Unknown and I4
if (!((NetworkBehaviour)__instance).isLocalPlayer)
{
return;
}
if ((int)itemType != 1)
{
if ((int)itemType != 4)
{
if ((int)itemType == 6)
{
BhapticsSDK2Wrapper.playParam("carthonk", 1, 0.5f, 0.5f, 0f, 0f);
}
}
else
{
BhapticsSDK2Wrapper.playParam("airhorn", 1, 1f, 0.5f, 0f, 0f);
}
}
else
{
BhapticsSDK2Wrapper.play("coffee");
}
}
[HarmonyPatch("PlayRocketLauncherShotForAllClients")]
[HarmonyPostfix]
public static void PostfixRocketLauncherShot(PlayerAudio __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.play("rocketlauncher");
}
}
[HarmonyPatch("PlayLandminePlantForAllClients")]
[HarmonyPostfix]
public static void PostfixLandminePlant(PlayerAudio __instance, bool stomp)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
if (stomp)
{
BhapticsSDK2Wrapper.play("minestomp");
}
else
{
BhapticsSDK2Wrapper.play("mineplant");
}
}
}
}
[HarmonyPatch(typeof(PlayerMovement))]
public class PlayerMovementPatches
{
public static bool _wasGrounded = false;
private static bool _hasPlayedDiveLand = false;
private static DivingState _previousDivingState = (DivingState)0;
private static double _lastCollisionTime = double.MinValue;
[HarmonyPatch("TriggerJumpInternal")]
[HarmonyPostfix]
public static void PostfixJump(PlayerMovement __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
_hasPlayedDiveLand = false;
BhapticsSDK2Wrapper.playParam("jump", 1, 0.3f, 1f, 0f, 0f);
}
}
[HarmonyPatch("UpdateGroundingState")]
[HarmonyPostfix]
public static void PostfixGrounding(PlayerMovement __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
bool isGrounded = __instance.IsGrounded;
if (isGrounded && !_wasGrounded && !_hasPlayedDiveLand)
{
BhapticsSDK2Wrapper.playParam("land", 1, 0.3f, 1f, 0f, 0f);
}
_wasGrounded = isGrounded;
}
}
[HarmonyPatch("SetDivingState")]
[HarmonyPostfix]
public static void PostfixDiveGrounded(PlayerMovement __instance, DivingState state)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Invalid comparison between Unknown and I4
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Invalid comparison between Unknown and I4
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Invalid comparison between Unknown and I4
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
if ((int)state == 1 && (int)_previousDivingState != 1)
{
_hasPlayedDiveLand = false;
BhapticsSDK2Wrapper.play("jump");
}
else if ((int)state == 2 && (int)_previousDivingState != 2)
{
BhapticsSDK2Wrapper.playParam("land", 1, 0.75f, 1f, 0f, 0f);
_hasPlayedDiveLand = true;
}
_previousDivingState = state;
}
}
[HarmonyPatch("PlayRespawnEffectsInternal")]
[HarmonyPostfix]
public static void PostfixRespawn(PlayerMovement __instance)
{
if (((NetworkBehaviour)__instance).isLocalPlayer)
{
BhapticsSDK2Wrapper.playParam("spawn", 1, 1f, 2.1f, 0f, 0f);
}
}
[HarmonyPatch("OnCollisionEnter")]
[HarmonyPostfix]
public static void PostfixCollision(PlayerMovement __instance, Collision collision)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
if (((NetworkBehaviour)__instance).isLocalPlayer && (__instance.IsKnockedOut || __instance.PlayerInfo.AsHittable.IsFrozen) && collision.contactCount > 0 && !((double)BMath.GetTimeSince(_lastCollisionTime) < 0.3))
{
Vector3 relativeVelocity = collision.relativeVelocity;
float magnitude = ((Vector3)(ref relativeVelocity)).magnitude;
if (!(magnitude < 5f))
{
float intensity = Mathf.Clamp01(Mathf.InverseLerp(5f, 25f, magnitude));
BhapticsSDK2Wrapper.playParam("playercollision", 0, intensity, 1f, 0f, 0f);
_lastCollisionTime = Time.timeAsDouble;
}
}
}
[HarmonyPatch("OnLocalPlayerWillApplyItemHitPhysics")]
[HarmonyPostfix]
public static void PostfixItemHit(ItemType itemType)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: 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_0031: 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_0055: Expected I4, but got Unknown
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Invalid comparison between Unknown and I4
if (GameManager.LocalPlayerInfo.isElectromagnetShieldActive && (int)itemType != 10)
{
BhapticsSDK2Wrapper.play("shieldhit");
return;
}
switch (itemType - 2)
{
default:
if ((int)itemType != 12)
{
break;
}
BhapticsSDK2Wrapper.playParam("frozen", 0, 0.25f, 1f, 0f, 0f);
return;
case 5:
case 6:
BhapticsSDK2Wrapper.play("smallexplode");
return;
case 1:
BhapticsSDK2Wrapper.playParam("shot", 0, 1f, 1f, 0f, 0f);
return;
case 0:
BhapticsSDK2Wrapper.playParam("shot", 0, 1f, 0.5f, 0f, 0f);
return;
case 2:
case 3:
case 4:
break;
}
BhapticsSDK2Wrapper.play("hit");
}
}
[HarmonyPatch(typeof(GolfCartInfo))]
public class GolfCartHonkPatches
{
[HarmonyPatch("PlayHonkForAllClients")]
[HarmonyPostfix]
public static void PostfixHonk(GolfCartInfo __instance)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
if (!((Object)(object)localPlayerInfo == (Object)null) && !((Object)(object)localPlayerInfo.ActiveGolfCartSeat.golfCart != (Object)(object)__instance) && localPlayerInfo.ActiveGolfCartSeat.seat == 0)
{
BhapticsSDK2Wrapper.playParam("carthonk", 1, 0.5f, 0.5f, 0f, 0f);
}
}
}
[HarmonyPatch(typeof(GolfCartMovement))]
public class GolfCartCollisionPatches
{
private const float velocityThreshold = 2f;
[HarmonyPatch("OnCollisionEnter")]
[HarmonyPostfix]
public static void PostfixCollision(GolfCartMovement __instance, Collision collision)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
if ((Object)(object)localPlayerInfo == (Object)null)
{
return;
}
GolfCartInfo golfCart = localPlayerInfo.ActiveGolfCartSeat.golfCart;
if (!((Object)(object)golfCart == (Object)null) && !((Object)(object)((Component)golfCart).GetComponent<GolfCartMovement>() != (Object)(object)__instance))
{
Vector3 relativeVelocity = collision.relativeVelocity;
float magnitude = ((Vector3)(ref relativeVelocity)).magnitude;
if (!(magnitude < 2f))
{
float intensity = Mathf.Clamp01(Mathf.InverseLerp(2f, 20f, magnitude));
BhapticsSDK2Wrapper.playParam("cartcollision", 0, intensity, 1f, 0f, 0f);
}
}
}
[HarmonyPatch("TryTriggerJump")]
[HarmonyPostfix]
public static void PostfixCartJump(GolfCartMovement __instance, bool __result)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
if (!__result)
{
return;
}
PlayerInfo localPlayerInfo = GameManager.LocalPlayerInfo;
if (!((Object)(object)localPlayerInfo == (Object)null))
{
GolfCartInfo golfCart = localPlayerInfo.ActiveGolfCartSeat.golfCart;
if (!((Object)(object)golfCart == (Object)null) && !((Object)(object)((Component)golfCart).GetComponent<GolfCartMovement>() != (Object)(object)__instance))
{
BhapticsSDK2Wrapper.play("jump");
}
}
}
}
[HarmonyPatch(typeof(JumpPad))]
public class JumpPadPatches
{
[HarmonyPatch("TryApplyJumpInternal")]
[HarmonyPostfix]
public static void PostfixJumpPad(Hittable hittable)
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
if (((NetworkBehaviour)hittable).isOwned)
{
if (!PlayerMovementPatches._wasGrounded)
{
BhapticsSDK2Wrapper.playParam("land", 1, 0.75f, 1f, 0f, 0f);
}
BhapticsSDK2Wrapper.play("jump");
return;
}
PlayerGolfer localPlayerAsGolfer = GameManager.LocalPlayerAsGolfer;
PlayerInfo val = ((localPlayerAsGolfer != null) ? ((Component)localPlayerAsGolfer).GetComponent<PlayerInfo>() : null);
if (!((Object)(object)val == (Object)null))
{
GolfCartInfo golfCart = val.ActiveGolfCartSeat.golfCart;
if (!((Object)(object)golfCart == (Object)null) && (Object)(object)golfCart.AsEntity.AsHittable == (Object)(object)hittable)
{
BhapticsSDK2Wrapper.play("jump");
}
}
}
}
[HarmonyPatch(typeof(Checkpoint))]
public class CheckpointPatches
{
[HarmonyPatch("SetIsVisuallyActive")]
[HarmonyPostfix]
public static void PostfixActivated(Checkpoint __instance, bool isActive, bool suppressEffects)
{
Checkpoint val = default(Checkpoint);
if (!(!isActive || suppressEffects) && CheckpointManager.TryGetLocalPlayerActiveCheckpoint(ref val) && !((Object)(object)val != (Object)(object)__instance))
{
BhapticsSDK2Wrapper.play("checkpoint");
}
}
}
[HarmonyPatch(typeof(UiSfx))]
public class UiSfxPatches
{
private static readonly MethodInfo ShouldSupressSfx = AccessTools.Method(typeof(UiSfx), "ShouldSupressSfx", (Type[])null, (Type[])null);
[HarmonyPatch("OnPointerEnter")]
[HarmonyPostfix]
public static void PostfixHover(UiSfx __instance)
{
if (!IsSuppressed(__instance))
{
BhapticsSDK2Wrapper.playParam("lightinteract", 1, 0.3f, 1f, 0f, 0f);
}
}
[HarmonyPatch("OnPointerClick")]
[HarmonyPostfix]
public static void PostfixClick(UiSfx __instance)
{
if (!IsSuppressed(__instance))
{
BhapticsSDK2Wrapper.playParam("heavyinteract", 1, 0.5f, 1f, 0f, 0f);
}
}
private static bool IsSuppressed(UiSfx instance)
{
return (bool)ShouldSupressSfx.Invoke(instance, null);
}
}
[BepInPlugin("ggsDylanSBGHaptics", "SBG Haptics", "1.0.0")]
public class HapticsPlugin : BaseUnityPlugin
{
public static ManualLogSource Log;
public static TactSuit Suit;
private PlayerInfo _localPlayerInfo;
private static bool IsCartRumblePlaying = false;
private static readonly float[] CartSpeedThresholds = new float[4]
{
4f,
8f,
11f,
float.MaxValue
};
private static readonly float[] CartHapticIntensities = new float[4] { 0.05f, 0.15f, 0.25f, 0.35f };
private static int _currentCartBand = -1;
private float _cartRumbleTimer = 0f;
private const float CartRumbleRetriggerInterval = 2.7f;
private const float AirborneMinVelocity = 10f;
private const float AirborneMaxVelocity = 25f;
private static bool IsAirbornePlaying = false;
private float _airborneTimer = 3.24f;
private const float AirbornePatternDuration = 3.24f;
private float _speedBoostHapticTimer = 0f;
private const float SpeedBoostHapticInterval = 0.34f;
public static bool IsOverchargeLoopPlaying = false;
private void Awake()
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"SBG Haptics: Log initialized.");
Suit = new TactSuit();
Log.LogInfo((object)"SBG Haptics: TactSuit initialized.");
Harmony val = new Harmony("ggsDylanSBGHaptics");
val.PatchAll();
Log.LogInfo((object)"SBG Haptics: Harmony patches applied.");
PlayerGolfer.LocalPlayerMatchResolutionChanged += OnLocalPlayerMatchResolutionChanged;
}
private void Update()
{
//IL_003e: 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_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: 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_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01e4: Invalid comparison between Unknown and I4
//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
//IL_01ed: Invalid comparison between Unknown and I4
//IL_0205: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Unknown result type (might be due to invalid IL or missing references)
//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_localPlayerInfo == (Object)null)
{
PlayerGolfer localPlayerAsGolfer = GameManager.LocalPlayerAsGolfer;
_localPlayerInfo = ((localPlayerAsGolfer != null) ? ((Component)localPlayerAsGolfer).GetComponent<PlayerInfo>() : null);
}
GolfCartSeat activeGolfCartSeat;
if ((Object)(object)_localPlayerInfo != (Object)null)
{
activeGolfCartSeat = _localPlayerInfo.ActiveGolfCartSeat;
if (((GolfCartSeat)(ref activeGolfCartSeat)).IsValid())
{
GolfCartInfo golfCart = _localPlayerInfo.ActiveGolfCartSeat.golfCart;
GolfCartMovement val = ((golfCart != null) ? ((Component)golfCart).GetComponent<GolfCartMovement>() : null);
if ((Object)(object)val != (Object)null)
{
Vector3 linearVelocity = val.AsEntity.Rigidbody.linearVelocity;
float magnitude = ((Vector3)(ref linearVelocity)).magnitude;
if (val.IsAnyWheelGrounded() && magnitude > 0.01f)
{
int cartBand = GetCartBand(magnitude);
_cartRumbleTimer += Time.deltaTime;
if (cartBand != _currentCartBand || _cartRumbleTimer >= 2.7f)
{
BhapticsSDK2Wrapper.stopByEventId("golfcartride");
BhapticsSDK2Wrapper.playLoop("golfcartride", 1, CartHapticIntensities[cartBand], 1f, 0f, 0f, 200, 999999);
_currentCartBand = cartBand;
_cartRumbleTimer = 0f;
IsCartRumblePlaying = true;
}
}
else
{
if (IsCartRumblePlaying)
{
BhapticsSDK2Wrapper.stopByEventId("golfcartride");
IsCartRumblePlaying = false;
_currentCartBand = -1;
}
_cartRumbleTimer = 0f;
}
}
goto IL_01c1;
}
}
if (IsCartRumblePlaying)
{
BhapticsSDK2Wrapper.stopByEventId("golfcartride");
IsCartRumblePlaying = false;
_currentCartBand = -1;
_cartRumbleTimer = 0f;
}
goto IL_01c1;
IL_01c1:
PlayerInfo localPlayerInfo = _localPlayerInfo;
PlayerMovement val2 = ((localPlayerInfo != null) ? localPlayerInfo.Movement : null);
bool flag = (Object)(object)val2 != (Object)null && (int)val2.DivingState == 1 && (int)val2.DiveType == 3;
int num;
if ((Object)(object)val2 != (Object)null)
{
activeGolfCartSeat = _localPlayerInfo.ActiveGolfCartSeat;
num = ((!((GolfCartSeat)(ref activeGolfCartSeat)).IsValid()) ? 1 : 0);
}
else
{
num = 0;
}
if (((uint)num & (flag ? 1u : 0u)) != 0)
{
_airborneTimer += Time.deltaTime;
if (_airborneTimer >= 3.24f)
{
_airborneTimer = 0f;
BhapticsSDK2Wrapper.playParam("airborne", 0, 1f, 3.24f, 0f, 0f);
IsAirbornePlaying = true;
}
}
else if (IsAirbornePlaying)
{
BhapticsSDK2Wrapper.stopByEventId("airborne");
IsAirbornePlaying = false;
_airborneTimer = 3.24f;
}
PlayerMovement localPlayerMovement = GameManager.LocalPlayerMovement;
if ((Object)(object)localPlayerMovement != (Object)null && StatusEffectExtensions.HasEffect(localPlayerMovement.StatusEffects, (StatusEffect)2) && !GameManager.LocalPlayerAsGolfer.IsMatchResolved)
{
_speedBoostHapticTimer += Time.deltaTime;
if (_speedBoostHapticTimer >= 0.34f)
{
_speedBoostHapticTimer = 0f;
float num2 = Mathf.Clamp01(localPlayerMovement.SpeedBoostRemainingTime / GameManager.PlayerMovementSettings.MaxSpeedBoostDuration);
if (num2 > 0f)
{
BhapticsSDK2Wrapper.playParam("heartbeat", 0, num2, 1f, 0f, 0f);
}
}
}
else
{
_speedBoostHapticTimer = 0.34f;
}
}
private static void OnLocalPlayerMatchResolutionChanged(PlayerMatchResolution previous, PlayerMatchResolution current)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if (PlayerMatchResolutionExtensions.IsResolved(current))
{
StopAllHaptics();
}
}
private void OnApplicationQuit()
{
StopAllHaptics();
}
private void OnDestroy()
{
PlayerGolfer.LocalPlayerMatchResolutionChanged -= OnLocalPlayerMatchResolutionChanged;
StopAllHaptics();
}
private static void StopAllHaptics()
{
BhapticsSDK2Wrapper.stopAll();
IsOverchargeLoopPlaying = false;
IsCartRumblePlaying = false;
IsAirbornePlaying = false;
}
private int GetCartBand(float velocity)
{
for (int i = 0; i < CartSpeedThresholds.Length; i++)
{
if (velocity < CartSpeedThresholds[i])
{
return i;
}
}
return CartHapticIntensities.Length - 1;
}
}
public class TactSuit
{
public string apiKey = "matJkzdE0KSXpJXdcEKY";
public string workspaceId = "69fa03cc2ff723c4ece0909e";
public TactSuit()
{
HapticsPlugin.Log.LogInfo((object)"Tactsuit: Constructor started");
try
{
if (!BhapticsSDK2Wrapper.isPlayerRunning())
{
HapticsPlugin.Log.LogInfo((object)"Tactsuit: Player not running, attempting launch...");
BhapticsSDK2Wrapper.launchPlayer(tryLaunch: true);
}
}
catch (Exception ex)
{
HapticsPlugin.Log.LogError((object)("Tactsuit: Error checking player status: " + ex.Message));
}
HapticsPlugin.Log.LogInfo((object)"Tactsuit: Attempting registryAndInit...");
if (BhapticsSDK2Wrapper.registryAndInit(apiKey, workspaceId, ""))
{
HapticsPlugin.Log.LogInfo((object)"Tactsuit: bHaptics connected!");
}
else
{
HapticsPlugin.Log.LogError((object)"Tactsuit: bHaptics FAILED to connect!");
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "SuperBattleGolf_Haptics";
public const string PLUGIN_NAME = "Super Battle Golf bHaptics integration";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace tact_csharp2
{
public class BhapticsSDK2Wrapper
{
private const string ModuleName = "bhaptics_library";
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool registryAndInit(string sdkAPIKey, string workspaceId, string initData);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool registryAndInitHost(string sdkAPIKey, string workspaceId, string initData, string url);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool wsIsConnected();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern void wsClose();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool reInitMessage(string sdkAPIKey, string workspaceId, string initData);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int play(string eventId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int playParam(string eventId, int requestId, float intensity, float duration, float angleX, float offsetY);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern void playWithStartTime(string eventId, int requestId, int startMillis, float intensity, float duration, float angleX, float offsetY);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int playDot(int requestId, int position, int durationMillis, int[] motors, int size);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int playWaveform(int requestId, int position, int[] motorValues, int[] playTimeValues, int[] shapeValues, int motorLen);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int playPath(int requestId, int position, float[] xValues, float[] yValues, int[] intensityValues, int Len);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int playLoop(string eventId, int requestId, float intensity, float duration, float angleX, float offsetY, int interval, int maxCount);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int getEventTime(string eventId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern int pause(string eventId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool resume(string eventId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool stop(int requestId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool stopByEventId(string eventId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool stopAll();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool isbHapticsConnected(int position);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool isPlaying();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool isPlayingByRequestId(int requestId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool isPlayingByEventId(string eventId);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool isPlayerRunning();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool isPlayerInstalled();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool launchPlayer(bool tryLaunch);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr getDeviceInfoJson();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr getHapticMappingsJson();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool ping(string address);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool pingAll();
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool swapPosition(string address);
[DllImport("bhaptics_library", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.I1)]
public static extern bool setDeviceVsm(string address, int vsm);
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
