using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("BubbleBoi")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BubbleBoi")]
[assembly: AssemblyTitle("BubbleBoi")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 BubbleBoi
{
[BepInPlugin("sbg.bubbleboi", "BubbleBoi", "0.2.2")]
public sealed class Plugin : BaseUnityPlugin
{
public const string ModGuid = "sbg.bubbleboi";
public const string ModName = "BubbleBoi";
public const string ModVersion = "0.2.2";
internal static ManualLogSource Log;
internal static Plugin Instance;
internal ConfigEntry<bool> verboseLoggingConfig;
internal ConfigEntry<float> expiryWarningSecondsConfig;
internal ConfigEntry<bool> expiryWarningEnabledConfig;
private void Awake()
{
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
verboseLoggingConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "VerboseLogging", false, "Emit per-frame water-walk decision logs. Off by default — flip on when reporting issues so the log shows why synthetic ground was/wasn't injected.");
expiryWarningEnabledConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Visuals", "ExpiryWarningEnabled", true, "Tint the local player's electromagnet shield orange→red in the final seconds before it expires.");
expiryWarningSecondsConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Visuals", "ExpiryWarningSeconds", 3.5f, "Window before shield expiry over which the warning hue ramps in. The first half is orange-tinted, the last half ramps to red.");
WaterSurfaceProxy.EnsureCreated();
new Harmony("sbg.bubbleboi").PatchAll();
Log.LogInfo((object)"BubbleBoi v0.2.2 loaded.");
}
}
internal static class WaterSurfaceProxy
{
private static BoxCollider collider;
internal static Collider Collider
{
get
{
EnsureCreated();
return (Collider)(object)collider;
}
}
internal static void EnsureCreated()
{
//IL_0013: 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_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)collider != (Object)null))
{
GameObject val = new GameObject("BubbleBoiWaterSurfaceProxy")
{
hideFlags = (HideFlags)61
};
Object.DontDestroyOnLoad((Object)val);
collider = val.AddComponent<BoxCollider>();
((Collider)collider).enabled = false;
((Collider)collider).isTrigger = false;
collider.size = new Vector3(1f, 0.1f, 1f);
}
}
}
internal sealed class ShieldExpiryTinter : MonoBehaviour
{
private static readonly Color OrangeWarning = new Color(1f, 0.55f, 0.1f, 1f);
private static readonly int[] ColorPropertyIds = new int[4]
{
Shader.PropertyToID("_TintColor"),
Shader.PropertyToID("_Color"),
Shader.PropertyToID("_BaseColor"),
Shader.PropertyToID("_EmissionColor")
};
private static ShieldExpiryTinter instance;
private static MaterialPropertyBlock block;
private PlayerInfo target;
private double activationTimestamp;
private Renderer[] cachedRenderers;
private readonly Dictionary<ParticleSystem, MinMaxGradient> originalStartColors = new Dictionary<ParticleSystem, MinMaxGradient>();
private bool tintApplied;
public static void OnLocalShieldActivated(PlayerInfo player)
{
EnsureInstance();
instance.target = player;
instance.activationTimestamp = Time.timeAsDouble;
instance.cachedRenderers = null;
instance.originalStartColors.Clear();
instance.tintApplied = false;
}
private static void EnsureInstance()
{
//IL_0013: 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_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
if (!((Object)(object)instance != (Object)null))
{
GameObject val = new GameObject("BubbleBoiShieldExpiryTinter")
{
hideFlags = (HideFlags)61
};
Object.DontDestroyOnLoad((Object)val);
instance = val.AddComponent<ShieldExpiryTinter>();
block = new MaterialPropertyBlock();
}
}
private void Update()
{
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)target == (Object)null)
{
return;
}
if (!target.IsElectromagnetShieldActive)
{
if (tintApplied)
{
ResetTint();
}
target = null;
cachedRenderers = null;
return;
}
Plugin plugin = Plugin.Instance;
if ((Object)(object)plugin == (Object)null || !plugin.expiryWarningEnabledConfig.Value)
{
if (tintApplied)
{
ResetTint();
}
return;
}
float num = (((Object)(object)GameManager.ItemSettings != (Object)null) ? GameManager.ItemSettings.ElectromagnetShieldDuration : 5f) - (float)(Time.timeAsDouble - activationTimestamp);
float value = plugin.expiryWarningSecondsConfig.Value;
if (num > value || num <= 0f)
{
if (tintApplied)
{
ResetTint();
}
}
else
{
float num2 = 1f - num / value;
Color tint = ((num2 < 0.5f) ? Color.Lerp(Color.white, OrangeWarning, num2 * 2f) : Color.Lerp(OrangeWarning, Color.red, (num2 - 0.5f) * 2f));
EnsureRenderers();
ApplyTint(tint);
tintApplied = true;
}
}
private void EnsureRenderers()
{
if ((cachedRenderers == null || cachedRenderers.Length == 0) && !((Object)(object)target == (Object)null) && !((Object)(object)target.ElectromagnetShieldCollider == (Object)null))
{
cachedRenderers = ((Component)target.ElectromagnetShieldCollider).GetComponentsInChildren<Renderer>(true);
}
}
private void ApplyTint(Color tint)
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: 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)
if (cachedRenderers == null)
{
return;
}
Renderer[] array = cachedRenderers;
ParticleSystem val2 = default(ParticleSystem);
foreach (Renderer val in array)
{
if ((Object)(object)val == (Object)null)
{
continue;
}
if (val is ParticleSystemRenderer && ((Component)val).TryGetComponent<ParticleSystem>(ref val2))
{
if (!originalStartColors.ContainsKey(val2))
{
Dictionary<ParticleSystem, MinMaxGradient> dictionary = originalStartColors;
ParticleSystem key = val2;
MainModule main = val2.main;
dictionary[key] = ((MainModule)(ref main)).startColor;
}
MainModule main2 = val2.main;
((MainModule)(ref main2)).startColor = new MinMaxGradient(tint);
}
else
{
val.GetPropertyBlock(block);
int[] colorPropertyIds = ColorPropertyIds;
foreach (int num in colorPropertyIds)
{
block.SetColor(num, tint);
}
val.SetPropertyBlock(block);
}
}
}
private void ResetTint()
{
//IL_0066: 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_0071: Unknown result type (might be due to invalid IL or missing references)
if (cachedRenderers != null)
{
Renderer[] array = cachedRenderers;
foreach (Renderer val in array)
{
if (!((Object)(object)val == (Object)null) && !(val is ParticleSystemRenderer))
{
val.SetPropertyBlock((MaterialPropertyBlock)null);
}
}
}
foreach (KeyValuePair<ParticleSystem, MinMaxGradient> originalStartColor in originalStartColors)
{
if (!((Object)(object)originalStartColor.Key == (Object)null))
{
MainModule main = originalStartColor.Key.main;
((MainModule)(ref main)).startColor = originalStartColor.Value;
}
}
originalStartColors.Clear();
tintApplied = false;
}
}
[HarmonyPatch]
internal static class WaterWalkPatches
{
private const float DecisionLogIntervalSeconds = 1f;
private static readonly FieldInfo UprightColliderField = AccessTools.Field(typeof(PlayerMovement), "uprightCollider");
private static readonly FieldInfo GroundDataField = AccessTools.Field(typeof(PlayerMovement), "<GroundData>k__BackingField");
private static readonly MethodInfo NoClipEnabledGetter = AccessTools.PropertyGetter(typeof(PlayerMovement), "NoClipEnabled");
private static readonly Dictionary<int, double> LastDecisionLogTimes = new Dictionary<int, double>();
private static readonly Dictionary<int, bool> LastInjectedGroundState = new Dictionary<int, bool>();
[HarmonyPatch(typeof(PlayerMovement), "PerformGroundCheck")]
[HarmonyPostfix]
private static void PerformGroundCheckPostfix(PlayerMovement __instance, ref bool __result)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: 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_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_0173: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
//IL_017b: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Unknown result type (might be due to invalid IL or missing references)
//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
//IL_021f: Unknown result type (might be due to invalid IL or missing references)
if (!TryGetWaterSurfacePoint(__instance, out var waterPoint, out var reason))
{
if (__result)
{
TrackInjectedGroundState(__instance, isInjected: false);
}
else
{
MaybeLogDecision(__instance, "synthetic ground skipped: " + reason);
}
TrackInjectedGroundState(__instance, isInjected: false);
return;
}
if (__result)
{
Vector3 point = __instance.GroundData.point;
if (point.y >= waterPoint.y - 0.05f)
{
MaybeLogDecision(__instance, $"keeping vanilla ground at y={point.y:F3} (water y={waterPoint.y:F3})");
TrackInjectedGroundState(__instance, isInjected: false);
return;
}
MaybeLogDecision(__instance, $"vanilla ground submerged y={point.y:F3} < water y={waterPoint.y:F3} — overriding with synthetic surface");
}
object? obj = UprightColliderField?.GetValue(__instance);
CapsuleCollider val = (CapsuleCollider)((obj is CapsuleCollider) ? obj : null);
if ((Object)(object)val == (Object)null)
{
MaybeLogDecision(__instance, "synthetic ground skipped: uprightCollider missing");
TrackInjectedGroundState(__instance, isInjected: false);
return;
}
Vector3 val2 = ((Component)val).transform.TransformPoint(val.center);
float num = val.center.y + 0.35f;
if (val2.y - waterPoint.y > num)
{
MaybeLogDecision(__instance, $"synthetic ground skipped: water surface too far below ray origin ({val2.y - waterPoint.y:F3}m > {num:F3}m)");
TrackInjectedGroundState(__instance, isInjected: false);
return;
}
__instance.NetworkgroundTerrainType = (GroundTerrainType)0;
__instance.NetworkgroundTerrainDominantGlobalLayer = (TerrainLayer)0;
GroundDataField?.SetValue(__instance, (object)new PlayerGroundData
{
point = waterPoint,
contactPoint = waterPoint,
normal = Vector3.up,
collider = WaterSurfaceProxy.Collider,
hasRigidbody = false,
rigidbody = null
});
bool flag = __result;
__result = true;
object[] obj2 = new object[4]
{
waterPoint.y,
__instance.Position.y,
flag,
null
};
PlayerInfo playerInfo = __instance.PlayerInfo;
BoundsState? obj3;
if (playerInfo == null)
{
obj3 = null;
}
else
{
LevelBoundsTracker levelBoundsTracker = playerInfo.LevelBoundsTracker;
obj3 = ((levelBoundsTracker != null) ? new BoundsState?(levelBoundsTracker.AuthoritativeBoundsState) : null);
}
obj2[3] = obj3;
MaybeLogDecision(__instance, string.Format("synthetic ground injected at waterY={0:F3}, playerY={1:F3}, replacedVanillaGround={2}, bounds={3}", obj2));
TrackInjectedGroundState(__instance, isInjected: true);
}
[HarmonyPatch(typeof(PlayerMovement), "FixedUpdate")]
[HarmonyPostfix]
private static void FixedUpdatePostfix(PlayerMovement __instance)
{
//IL_004e: 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_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
if (!TryGetWaterSurfacePoint(__instance, out var waterPoint, out var _))
{
return;
}
PlayerInfo playerInfo = __instance.PlayerInfo;
if ((Object)(object)((playerInfo != null) ? playerInfo.LevelBoundsTracker : null) == (Object)null)
{
return;
}
PlayerInfo playerInfo2 = __instance.PlayerInfo;
Rigidbody val = ((playerInfo2 != null) ? playerInfo2.Rigidbody : null);
if ((Object)(object)val == (Object)null || val.isKinematic)
{
return;
}
Vector3 position = val.position;
if (!(position.y >= waterPoint.y))
{
float num = waterPoint.y - position.y;
position.y = waterPoint.y;
val.position = position;
Vector3 linearVelocity = val.linearVelocity;
if (linearVelocity.y < 0f)
{
linearVelocity.y = 0f;
val.linearVelocity = linearVelocity;
}
MaybeLogDecision(__instance, $"surface correction applied: raised by {num:F3}m to waterY={waterPoint.y:F3}", force: true);
}
}
[HarmonyPatch(typeof(PlayerMovement), "OnServerBoundsStateChanged")]
[HarmonyPrefix]
private static bool OnServerBoundsStateChangedPrefix(PlayerMovement __instance, BoundsState currentState)
{
//IL_0000: 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_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
if (!BoundsStateExtensions.IsInOutOfBoundsHazard(currentState))
{
return true;
}
if (!ShouldWaterWalk(__instance))
{
MaybeLogDecision(__instance, $"server hazard passthrough: currentState={currentState}, reason=water-walk conditions not met");
return true;
}
PlayerInfo playerInfo = __instance.PlayerInfo;
if (IsWaterHazard((playerInfo != null) ? playerInfo.LevelBoundsTracker : null, currentState))
{
MaybeLogDecision(__instance, $"server water elimination suppressed: currentState={currentState}");
return false;
}
MaybeLogDecision(__instance, $"server hazard passthrough: currentState={currentState}, reason=hazard is not water");
return true;
}
private static bool TryGetWaterSurfacePoint(PlayerMovement movement, out Vector3 waterPoint, out string reason)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: 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)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
waterPoint = default(Vector3);
reason = string.Empty;
if (!ShouldWaterWalkLocally(movement))
{
reason = "local water-walk conditions not met";
return false;
}
PlayerInfo playerInfo = movement.PlayerInfo;
LevelBoundsTracker val = ((playerInfo != null) ? playerInfo.LevelBoundsTracker : null);
if ((Object)(object)val == (Object)null)
{
reason = "level bounds tracker missing";
return false;
}
if (!IsWaterHazard(val, val.AuthoritativeBoundsState) && !val.IsInOrOverOutOfBoundsHazard())
{
reason = $"not over a water hazard (bounds={val.AuthoritativeBoundsState})";
return false;
}
waterPoint = movement.Position;
waterPoint.y = val.CurrentOutOfBoundsHazardWorldHeightLocalOnly;
return true;
}
private static bool ShouldWaterWalk(PlayerMovement movement)
{
//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)
if ((Object)(object)movement == (Object)null)
{
return false;
}
if ((Object)(object)movement.PlayerInfo == (Object)null || !movement.PlayerInfo.IsElectromagnetShieldActive)
{
return false;
}
GolfCartSeat activeGolfCartSeat = movement.PlayerInfo.ActiveGolfCartSeat;
if (((GolfCartSeat)(ref activeGolfCartSeat)).IsValid())
{
return false;
}
if ((bool)(NoClipEnabledGetter?.Invoke(null, null) ?? ((object)false)))
{
return false;
}
return true;
}
private static bool ShouldWaterWalkLocally(PlayerMovement movement)
{
if ((Object)(object)movement != (Object)null && ((NetworkBehaviour)movement).isLocalPlayer)
{
return ShouldWaterWalk(movement);
}
return false;
}
private static void TrackInjectedGroundState(PlayerMovement movement, bool isInjected)
{
if (!((Object)(object)movement == (Object)null))
{
int instanceID = ((Object)movement).GetInstanceID();
if (!LastInjectedGroundState.TryGetValue(instanceID, out var value) || value != isInjected)
{
LastInjectedGroundState[instanceID] = isInjected;
MaybeLogDecision(movement, isInjected ? "synthetic ground state changed: active" : "synthetic ground state changed: inactive", force: true);
}
}
}
private static void MaybeLogDecision(PlayerMovement movement, string message, bool force = false)
{
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: 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_019d: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)movement == (Object)null || Plugin.Log == null || (Object)(object)Plugin.Instance == (Object)null || !Plugin.Instance.verboseLoggingConfig.Value)
{
return;
}
int instanceID = ((Object)movement).GetInstanceID();
double timeAsDouble = Time.timeAsDouble;
if (force || !LastDecisionLogTimes.TryGetValue(instanceID, out var value) || !(timeAsDouble - value < 1.0))
{
LastDecisionLogTimes[instanceID] = timeAsDouble;
PlayerInfo playerInfo = movement.PlayerInfo;
LevelBoundsTracker val = ((playerInfo != null) ? playerInfo.LevelBoundsTracker : null);
ManualLogSource log = Plugin.Log;
string[] obj = new string[12]
{
"[BubbleBoi] player=",
((playerInfo != null) ? ((Object)playerInfo).name : null) ?? ((Object)movement).name,
" ",
$"local={((NetworkBehaviour)movement).isLocalPlayer} shield={playerInfo != null && playerInfo.IsElectromagnetShieldActive} ",
$"grounded={movement.IsGrounded} visible={movement.IsVisible} ",
null,
null,
null,
null,
null,
null,
null
};
int num;
if (playerInfo == null)
{
num = 0;
}
else
{
GolfCartSeat activeGolfCartSeat = playerInfo.ActiveGolfCartSeat;
num = (((GolfCartSeat)(ref activeGolfCartSeat)).IsValid() ? 1 : 0);
}
obj[5] = $"inCart={(byte)num != 0} ";
obj[6] = "bounds=";
object obj2;
if (!((Object)(object)val != (Object)null))
{
obj2 = "null";
}
else
{
BoundsState authoritativeBoundsState = val.AuthoritativeBoundsState;
obj2 = ((object)(BoundsState)(ref authoritativeBoundsState)).ToString();
}
obj[7] = (string)obj2;
obj[8] = " waterY=";
obj[9] = (((Object)(object)val != (Object)null) ? val.CurrentOutOfBoundsHazardWorldHeightLocalOnly.ToString("F3") : "n/a");
obj[10] = " ";
obj[11] = $"posY={movement.Position.y:F3} :: {message}";
log.LogInfo((object)string.Concat(obj));
}
}
[HarmonyPatch(typeof(PlayerInfo), "LocalPlayerActivateElectromagnetShield")]
[HarmonyPostfix]
private static void LocalPlayerActivateElectromagnetShieldPostfix(PlayerInfo __instance)
{
ShieldExpiryTinter.OnLocalShieldActivated(__instance);
}
private static bool IsWaterHazard(LevelBoundsTracker tracker, BoundsState boundsState)
{
//IL_000b: 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_001a: Invalid comparison between Unknown and I4
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Invalid comparison between Unknown and I4
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Invalid comparison between Unknown and I4
if ((Object)(object)tracker == (Object)null)
{
return false;
}
if (BoundsStateExtensions.HasState(boundsState, (BoundsState)1))
{
return (int)MainOutOfBoundsHazard.Type == 0;
}
if ((Object)(object)tracker.CurrentSecondaryHazardLocalOnly != (Object)null)
{
return (int)tracker.CurrentSecondaryHazardLocalOnly.Type == 0;
}
return (int)MainOutOfBoundsHazard.Type == 0;
}
}
}
