using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using FishNet.Object;
using FishNet.Object.Synchronizing;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
[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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 MutatedWhalePhases
{
internal static class BallisticUtils
{
public static Vector3 SolveVelocityForFlightTime(Vector3 start, Vector3 end, float flightTime, float gravity)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: 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_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
flightTime = Mathf.Max(flightTime, 0.1f);
Vector3 val = end - start;
Vector3 val2 = new Vector3(val.x, 0f, val.z);
float y = val.y;
Vector3 val3 = val2 / flightTime;
float num = y / flightTime + 0.5f * gravity * flightTime;
return val3 + Vector3.up * num;
}
public static Vector3 PositionAtTime(Vector3 start, Vector3 initialVelocity, float gravity, float time)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: 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_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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)
Vector3 result = start + initialVelocity * time;
result.y -= 0.5f * gravity * time * time;
return result;
}
}
[HarmonyPatch(typeof(PlayerHands))]
internal static class BoatHandVisualPatch
{
private static readonly FieldInfo PlayerField = AccessTools.Field(typeof(PlayerHands), "_player");
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPrefix]
private static bool BeforeDrivenBoatGetter(PlayerHands __instance, ref Boat __result)
{
if (!BowheadWhaleAccess.IsSecondPhaseActive())
{
return true;
}
object? value = PlayerField.GetValue(__instance);
Player val = (Player)((value is Player) ? value : null);
if ((Object)(object)val == (Object)null || !Object.op_Implicit((Object)(object)val.Holding.HeldItem))
{
return true;
}
__result = null;
return false;
}
}
[HarmonyPatch]
internal static class BoatItemGatePatch
{
private static readonly MethodInfo IsDrivingLocallyGetter = AccessTools.PropertyGetter(typeof(Boat), "IsDrivingLocally");
private static readonly MethodInfo WantToDriveGetter = AccessTools.PropertyGetter(typeof(Boat), "WantToDrive");
private static readonly MethodInfo BypassIsDrivingLocallyMethod = AccessTools.Method(typeof(BoatItemGatePatch), "BypassIsDrivingLocally", (Type[])null, (Type[])null);
private static readonly MethodInfo BypassWantToDriveMethod = AccessTools.Method(typeof(BoatItemGatePatch), "BypassWantToDrive", (Type[])null, (Type[])null);
private static bool BypassIsDrivingLocally()
{
if (!BowheadWhaleAccess.IsSecondPhaseActive())
{
return Boat.IsDrivingLocally;
}
return false;
}
private static bool BypassWantToDrive()
{
if (!BowheadWhaleAccess.IsSecondPhaseActive())
{
return Boat.WantToDrive;
}
return false;
}
private static IEnumerable<CodeInstruction> Transpile(IEnumerable<CodeInstruction> instructions)
{
foreach (CodeInstruction instruction in instructions)
{
if (CodeInstructionExtensions.Calls(instruction, IsDrivingLocallyGetter))
{
yield return new CodeInstruction(OpCodes.Call, (object)BypassIsDrivingLocallyMethod);
}
else if (CodeInstructionExtensions.Calls(instruction, WantToDriveGetter))
{
yield return new CodeInstruction(OpCodes.Call, (object)BypassWantToDriveMethod);
}
else
{
yield return instruction;
}
}
}
[HarmonyPatch(typeof(PlayerInventory), "DeselectSlotInput")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TranspileDeselectSlotInput(IEnumerable<CodeInstruction> instructions)
{
return Transpile(instructions);
}
[HarmonyPatch(typeof(PlayerInventory), "SelectSlotInput")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TranspileSelectSlotInput(IEnumerable<CodeInstruction> instructions)
{
return Transpile(instructions);
}
[HarmonyPatch(typeof(PlayerInventory), "ScrollSlotInput")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TranspileScrollSlotInput(IEnumerable<CodeInstruction> instructions)
{
return Transpile(instructions);
}
[HarmonyPatch(typeof(PlayerInventory), "ChangeBaitInput")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TranspileChangeBaitInput(IEnumerable<CodeInstruction> instructions)
{
return Transpile(instructions);
}
[HarmonyPatch(typeof(PlayerHolding), "ScanForGrabbableItem")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TranspileScanForGrabbableItem(IEnumerable<CodeInstruction> instructions)
{
return Transpile(instructions);
}
[HarmonyPatch(typeof(PlayerHolding), "ScanForInteractable")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TranspileScanForInteractable(IEnumerable<CodeInstruction> instructions)
{
return Transpile(instructions);
}
[HarmonyPatch(typeof(PlayerPunching), "PunchInput")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TranspilePunchInput(IEnumerable<CodeInstruction> instructions)
{
return Transpile(instructions);
}
}
[HarmonyPatch]
internal static class BoatPhaseTwoPatch
{
private static readonly FieldInfo DriverField = AccessTools.Field(typeof(Boat), "_driver");
[HarmonyPatch(typeof(Boat), "TrySetDriver")]
[HarmonyPrefix]
private static bool BeforeTrySetDriver(Boat __instance, Player newDriver)
{
if (!BowheadWhaleAccess.IsSecondPhaseActive())
{
return true;
}
if (Object.op_Implicit((Object)(object)__instance.Driver) && Object.op_Implicit((Object)(object)newDriver))
{
return false;
}
((SyncVar<Player>)DriverField.GetValue(__instance)).Value = newDriver;
return false;
}
}
internal static class BowheadWhaleAccess
{
private static readonly FieldInfo ActiveWhaleField = typeof(BowheadWhale).GetField("_whale", BindingFlags.Static | BindingFlags.NonPublic);
public static bool TryGetActiveBoss(out BowheadWhale whale)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Invalid comparison between Unknown and I4
object? value = ActiveWhaleField.GetValue(null);
whale = (BowheadWhale)((value is BowheadWhale) ? value : null);
if ((Object)(object)whale != (Object)null && (int)((Creature)whale).BossType == 2)
{
return !((Creature)whale).IsDead;
}
return false;
}
public static bool IsSecondPhaseActive()
{
if (TryGetActiveBoss(out var whale))
{
return whale._inSecondPhase.Value;
}
return false;
}
}
internal static class DebugKeys
{
private static readonly MethodInfo SpawnMutatedWhaleMethod = AccessTools.Method(typeof(MainLava), "SpawnMutatedWhale", (Type[])null, (Type[])null);
private static readonly FieldInfo IsSpawningWhaleField = AccessTools.Field(typeof(MainLava), "_isSpawningWhale");
public static void Update()
{
Keyboard current = Keyboard.current;
if (current != null)
{
if (((ButtonControl)current.jKey).wasPressedThisFrame)
{
TrySpawnWhale();
}
if (((ButtonControl)current.kKey).wasPressedThisFrame)
{
TrySetBossHpPercent(0.49f);
}
if (((ButtonControl)current.lKey).wasPressedThisFrame)
{
TrySetBossHpPercent(0.09f);
}
}
}
private static void TrySpawnWhale()
{
if (!((Object)(object)BossManager.Boss != (Object)null))
{
MainLava val = Object.FindAnyObjectByType<MainLava>();
if (!((Object)(object)val == (Object)null) && !(bool)IsSpawningWhaleField.GetValue(val))
{
((MonoBehaviour)val).StartCoroutine((IEnumerator)SpawnMutatedWhaleMethod.Invoke(val, null));
}
}
}
private static void TrySetBossHpPercent(float targetPercent)
{
Creature boss = BossManager.Boss;
if (!((Object)(object)boss == (Object)null) && !boss.IsDead)
{
int num = Mathf.Max(1, Mathf.RoundToInt((float)BossManager.BossMaxHp * targetPercent));
int num2 = boss.Hp - num;
if (num2 > 0)
{
boss.ServerChangeHp(num2);
}
}
}
}
[BepInPlugin("community.howtofish.mutatedwhalephases", "Mutated Whale Phases", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "community.howtofish.mutatedwhalephases";
public const string PluginName = "Mutated Whale Phases";
public const string PluginVersion = "1.0.0";
private Harmony _harmony;
private void Awake()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
_harmony = new Harmony("community.howtofish.mutatedwhalephases");
_harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Mutated Whale Phases loaded: lava reflect + third phase patches applied.");
}
private void Update()
{
DebugKeys.Update();
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
}
[HarmonyPatch]
internal static class SecondPhaseLaunchPatch
{
private const float MinFlightTime = 3.5f;
private const float FlightSpeedCap = 40f;
private const float LaunchHeightBonus = 25f;
private const float LandingSnapDistance = 10f;
private const float ScreenShakeDuration = 3f;
private const float TargetDistanceMultiplier = 4f;
private static readonly FieldInfo RigField = AccessTools.Field(typeof(PlayerMovement), "_rig");
private static readonly FieldInfo ExtraGravityForceField = AccessTools.Field(typeof(PlayerMovement), "_extraGravityForce");
private static readonly FieldInfo PlayerField = AccessTools.Field(typeof(PlayerMovement), "_player");
private static float GetGravity(PlayerMovement movement)
{
return (float)ExtraGravityForceField.GetValue(movement);
}
[HarmonyPatch(typeof(BowheadWhale), "OnHealthChange")]
[HarmonyPostfix]
private static void AfterOnHealthChange(BowheadWhale __instance, bool asServer)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Invalid comparison between Unknown and I4
if (asServer && (int)((Creature)__instance).BossType == 2 && __instance._inSecondPhase.Value && !SecondPhaseSequenceState.SequenceTriggered)
{
SecondPhaseSequenceState.SequenceTriggered = true;
((MonoBehaviour)__instance).StartCoroutine(RunLaunchSequence(__instance));
}
}
private static IEnumerator RunLaunchSequence(BowheadWhale whale)
{
Vector3 position = ((Component)whale).transform.position;
Vector3 targetPos = (SecondPhaseSequenceState.TargetPosition = ComputeOpenWaterTarget(position));
foreach (Player alivePlayer in PlayerManager.AlivePlayers)
{
alivePlayer.ScreenShake.ConstantShake(true);
}
yield return null;
LaunchAllPlayers(targetPos);
LaunchBoatToFollow(targetPos);
while (SecondPhaseSequenceState.FlyingPlayers.Count > 0)
{
yield return null;
}
SnapBoatAndPlayersToLanding(targetPos);
foreach (Player alivePlayer2 in PlayerManager.AlivePlayers)
{
alivePlayer2.ScreenShake.ConstantShake(false);
}
SecondPhaseWhaleFollowPatch.BeginFollow(whale, BoatManager.Boat);
}
private static Vector3 ComputeOpenWaterTarget(Vector3 whalePos)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: 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_0010: 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_002c: 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_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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_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)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: 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_0092: 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)
int totalIslands = IslandManager.TotalIslands;
if (totalIslands <= 0)
{
Vector3 val = whalePos - Island.IslandPos;
Vector3 val2;
if (!(((Vector3)(ref val)).sqrMagnitude > 1f))
{
val2 = Vector3.forward;
}
else
{
val = whalePos - Island.IslandPos;
val2 = ((Vector3)(ref val)).normalized;
}
Vector3 val3 = val2;
Vector3 result = Island.IslandPos + val3 * (Island.IslandSize * 4f);
result.y = WaterManager.WaterHeight;
return result;
}
Vector3 val4 = Vector3.zero;
int num = 0;
for (int i = 0; i < totalIslands; i++)
{
IslandInfo islandInfo;
try
{
islandInfo = IslandManager.GetIslandInfo(i);
}
catch
{
continue;
}
if (islandInfo != null)
{
val4 += islandInfo.IslandPosition;
num++;
}
}
Vector3 result2 = ((num > 0) ? (val4 / (float)num) : Island.IslandPos);
result2.y = WaterManager.WaterHeight;
return result2;
}
private static void LaunchAllPlayers(Vector3 targetPos)
{
//IL_001e: 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_0024: 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_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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: 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_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_0081: Unknown result type (might be due to invalid IL or missing references)
foreach (Player alivePlayer in PlayerManager.AlivePlayers)
{
Vector3 position = alivePlayer.Transform.position;
Vector3 val = targetPos + Vector3.up * 25f;
float num = Vector3.Distance(position, val);
float num2 = Mathf.Max(3.5f, num / 40f);
float gravity = GetGravity(alivePlayer.Movement);
Vector3 linearVelocity = BallisticUtils.SolveVelocityForFlightTime(position, val, num2, gravity);
Rigidbody rigidbody = alivePlayer.Rigidbody;
if ((Object)(object)rigidbody != (Object)null)
{
rigidbody.linearVelocity = linearVelocity;
}
SecondPhaseSequenceState.FlyingPlayers.Add(alivePlayer);
SecondPhaseSequenceState.LaunchTime[alivePlayer] = Time.time;
SecondPhaseSequenceState.FlightDuration[alivePlayer] = num2;
}
SecondPhaseSequenceState.PlayersAirborne = true;
}
private static void LaunchBoatToFollow(Vector3 targetPos)
{
Boat boat = BoatManager.Boat;
if (!((Object)(object)boat == (Object)null))
{
boat.HiddenPhysicsRig.isKinematic = true;
}
}
[HarmonyPatch(typeof(PlayerMovement), "Move")]
[HarmonyPrefix]
private static bool BeforeMove(PlayerMovement __instance)
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
object? value = PlayerField.GetValue(__instance);
Player val = (Player)((value is Player) ? value : null);
if ((Object)(object)val == (Object)null || !SecondPhaseSequenceState.FlyingPlayers.Contains(val))
{
return true;
}
object? value2 = RigField.GetValue(__instance);
Rigidbody val2 = (Rigidbody)((value2 is Rigidbody) ? value2 : null);
if ((Object)(object)val2 == (Object)null)
{
return true;
}
val2.linearVelocity += Vector3.down * (GetGravity(__instance) * Time.fixedDeltaTime);
TryLandPlayer(val, val2);
return false;
}
private static void TryLandPlayer(Player player, Rigidbody rig)
{
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//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_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
Boat boat = BoatManager.Boat;
if (!((Object)(object)boat == (Object)null))
{
FollowPlayersWithBoat(boat);
float value;
float num = (SecondPhaseSequenceState.LaunchTime.TryGetValue(player, out value) ? value : Time.time);
float value2;
float num2 = (SecondPhaseSequenceState.FlightDuration.TryGetValue(player, out value2) ? value2 : 3.5f);
bool num3 = Time.time - num >= num2 + 1.5f;
Vector3 val = rig.position - boat.HiddenPhysicsRig.position;
bool flag = ((Vector3)(ref val)).sqrMagnitude <= 100f && rig.position.y <= boat.HiddenPhysicsRig.position.y + 3f;
if (num3 || flag)
{
SecondPhaseSequenceState.FlyingPlayers.Remove(player);
rig.linearVelocity = Vector3.zero;
}
}
}
private static void FollowPlayersWithBoat(Boat boat)
{
//IL_0000: 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_001f: 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)
//IL_002c: 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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: 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_007a: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = Vector3.zero;
int num = 0;
foreach (Player flyingPlayer in SecondPhaseSequenceState.FlyingPlayers)
{
val += flyingPlayer.Transform.position;
num++;
}
if (num != 0)
{
Vector3 val2 = val / (float)num;
Vector3 val3 = default(Vector3);
((Vector3)(ref val3))..ctor(val2.x, WaterManager.WaterHeight, val2.z);
boat.HiddenPhysicsRig.MovePosition(val3);
}
}
private static void SnapBoatAndPlayersToLanding(Vector3 targetPos)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
Boat boat = BoatManager.Boat;
if ((Object)(object)boat != (Object)null)
{
Vector3 val = default(Vector3);
((Vector3)(ref val))..ctor(targetPos.x, WaterManager.WaterHeight, targetPos.z);
boat.HiddenPhysicsRig.MovePosition(val);
boat.HiddenPhysicsRig.isKinematic = false;
}
SecondPhaseSequenceState.PlayersAirborne = false;
}
}
internal static class SecondPhaseSequenceState
{
public static bool SequenceTriggered;
public static bool PlayersAirborne;
public static Vector3 TargetPosition;
public static readonly HashSet<Player> FlyingPlayers = new HashSet<Player>();
public static readonly Dictionary<Player, float> LaunchTime = new Dictionary<Player, float>();
public static readonly Dictionary<Player, float> FlightDuration = new Dictionary<Player, float>();
public static void Reset()
{
//IL_000c: 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)
SequenceTriggered = false;
PlayersAirborne = false;
TargetPosition = Vector3.zero;
FlyingPlayers.Clear();
LaunchTime.Clear();
FlightDuration.Clear();
}
}
[HarmonyPatch(typeof(BowheadWhale))]
internal static class SecondPhaseTargetPriorityPatch
{
private const int LethalDamage = 99999;
private static readonly FieldInfo TargetField = AccessTools.Field(typeof(AttackingFish), "_target");
private static Player _priorityTarget;
[HarmonyPatch("UpdateMovement")]
[HarmonyPostfix]
private static void AfterUpdateMovement(BowheadWhale __instance)
{
if (!BowheadWhaleAccess.IsSecondPhaseActive() || !((NetworkBehaviour)__instance).IsServerInitialized)
{
_priorityTarget = null;
return;
}
Player val = (_priorityTarget = FindPlayerInWater());
if ((Object)(object)val != (Object)null)
{
TargetField.SetValue(__instance, val);
}
}
private static Player FindPlayerInWater()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
foreach (Player alivePlayer in PlayerManager.AlivePlayers)
{
bool num = (Object)(object)alivePlayer.Movement != (Object)null && alivePlayer.Movement.OnBoat;
bool flag = alivePlayer.Transform.position.y <= WaterManager.WaterHeight;
if (!num && flag)
{
return alivePlayer;
}
}
return null;
}
[HarmonyPatch("DamageOnCollision")]
[HarmonyPrefix]
private static bool BeforeDamageOnCollision(BowheadWhale __instance, Player player, Vector3 pos)
{
//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 (!BowheadWhaleAccess.IsSecondPhaseActive() || (Object)(object)_priorityTarget == (Object)null || (Object)(object)player != (Object)(object)_priorityTarget)
{
return true;
}
Server.Instance.HitPlayer(player, 99999, Vector3.zero, pos, (byte)2, (Player)null);
return false;
}
}
[HarmonyPatch(typeof(BowheadWhale))]
internal static class SecondPhaseWhaleFollowPatch
{
private const float RoarShakeDuration = 3f;
private const float BowOffsetDistance = 20f;
private const float MinFlightTime = 2.5f;
private const float SpeedCap = 60f;
private static readonly FieldInfo RigField = AccessTools.Field(typeof(Item), "_rig");
private static readonly FieldInfo JumpsLeftField = AccessTools.Field(typeof(BowheadWhale), "_jumpsLeft");
private static readonly FieldInfo AddedFlyingGravity2Field = AccessTools.Field(typeof(BowheadWhale), "_addedFlyingGravity2");
private static readonly MethodInfo FlyMethod = AccessTools.Method(typeof(BowheadWhale), "Fly", (Type[])null, (Type[])null);
private static readonly MethodInfo MakeNoiseSoundMethod = AccessTools.Method(typeof(BowheadWhale), "MakeNoiseSound", (Type[])null, (Type[])null);
private static float GetGravity(BowheadWhale whale)
{
return (float)AddedFlyingGravity2Field.GetValue(whale);
}
public static void BeginFollow(BowheadWhale whale, Boat boat)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: 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_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
SecondPhaseWhaleFollowState secondPhaseWhaleFollowState = SecondPhaseWhaleFollowState.Get(whale);
Vector3 val = ComputeBowTarget(whale, boat);
secondPhaseWhaleFollowState.Active = true;
secondPhaseWhaleFollowState.HasSurfaced = false;
secondPhaseWhaleFollowState.TargetPosition = val;
secondPhaseWhaleFollowState.IsDescending = false;
object? value = RigField.GetValue(whale);
Rigidbody val2 = (Rigidbody)((value is Rigidbody) ? value : null);
Vector3 val3 = (((Object)(object)val2 != (Object)null) ? val2.worldCenterOfMass : ((Component)whale).transform.position);
float num = Vector3.Distance(val3, val);
float flightTime = Mathf.Max(2.5f, num / 60f);
Vector3 linearVelocity = BallisticUtils.SolveVelocityForFlightTime(val3, val, flightTime, GetGravity(whale));
JumpsLeftField.SetValue(whale, 1);
FlyMethod.Invoke(whale, null);
if ((Object)(object)val2 != (Object)null)
{
val2.linearVelocity = linearVelocity;
}
}
private static Vector3 ComputeBowTarget(BowheadWhale whale, Boat boat)
{
//IL_0017: 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_0024: 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)
//IL_0059: 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_0064: 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_0076: 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)
Vector3 val = (((Object)(object)boat != (Object)null && (Object)(object)boat.VisualBoat != (Object)null) ? boat.VisualBoat.forward : Vector3.forward);
Vector3 result = (((Object)(object)boat != (Object)null && (Object)(object)boat.VisualBoat != (Object)null) ? boat.VisualBoat.position : ((Component)whale).transform.position) + val * 20f;
result.y = WaterManager.WaterHeight;
return result;
}
[HarmonyPatch("InitializeMovement")]
[HarmonyPrefix]
private static bool BeforeInitializeMovement(BowheadWhale __instance)
{
return !SecondPhaseWhaleFollowState.Get(__instance).Active;
}
[HarmonyPatch("SetFlying")]
[HarmonyPrefix]
private static bool BeforeSetFlying(BowheadWhale __instance)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: 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_00be: Unknown result type (might be due to invalid IL or missing references)
SecondPhaseWhaleFollowState secondPhaseWhaleFollowState = SecondPhaseWhaleFollowState.Get(__instance);
if (!secondPhaseWhaleFollowState.Active || secondPhaseWhaleFollowState.HasSurfaced)
{
return true;
}
object? value = RigField.GetValue(__instance);
Rigidbody val = (Rigidbody)((value is Rigidbody) ? value : null);
if ((Object)(object)val == (Object)null)
{
return true;
}
Vector3 linearVelocity = val.linearVelocity;
linearVelocity.y -= GetGravity(__instance) * Time.fixedDeltaTime;
val.linearVelocity = linearVelocity;
if (!(val.worldCenterOfMass.y <= WaterManager.WaterHeight) || !(linearVelocity.y < -1f))
{
secondPhaseWhaleFollowState.IsDescending = false;
return false;
}
if (!secondPhaseWhaleFollowState.IsDescending)
{
secondPhaseWhaleFollowState.IsDescending = true;
secondPhaseWhaleFollowState.DescendStartTime = Time.time;
return false;
}
if (Time.time - secondPhaseWhaleFollowState.DescendStartTime >= 0.6f)
{
secondPhaseWhaleFollowState.HasSurfaced = true;
PlaySplashBurst(val.position, 6, 5f);
JumpsLeftField.SetValue(__instance, 1);
FlyMethod.Invoke(__instance, null);
((MonoBehaviour)__instance).StartCoroutine(RoarAfterSurfacing(__instance, val));
}
return false;
}
private static IEnumerator RoarAfterSurfacing(BowheadWhale whale, Rigidbody rig)
{
foreach (Player alivePlayer in PlayerManager.AlivePlayers)
{
alivePlayer.ScreenShake.ConstantShake(true);
}
MakeNoiseSoundMethod.Invoke(whale, new object[1] { true });
PlaySplashBurst(new Vector3(rig.position.x, WaterManager.WaterHeight, rig.position.z), 14, 9f);
yield return (object)new WaitForSeconds(3f);
foreach (Player alivePlayer2 in PlayerManager.AlivePlayers)
{
alivePlayer2.ScreenShake.ConstantShake(false);
}
SecondPhaseWhaleFollowState.Get(whale).Active = false;
}
private static void PlaySplashBurst(Vector3 center, int count, float radius)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: 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_001e: 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)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < count; i++)
{
Vector3 val = Random.insideUnitSphere * radius;
val.y = 0f;
Vector3 val2 = center + val;
val2.y = WaterManager.WaterHeight;
VFXManager.Play("WaterSplash", val2, Vector3.zero);
}
}
}
internal sealed class SecondPhaseWhaleFollowState
{
public bool Active;
public bool HasSurfaced;
public Vector3 TargetPosition;
public bool IsDescending;
public float DescendStartTime = -1f;
private static readonly ConditionalWeakTable<BowheadWhale, SecondPhaseWhaleFollowState> States = new ConditionalWeakTable<BowheadWhale, SecondPhaseWhaleFollowState>();
public static SecondPhaseWhaleFollowState Get(BowheadWhale whale)
{
return States.GetOrCreateValue(whale);
}
}
[HarmonyPatch(typeof(BowheadWhale))]
internal static class ThirdPhasePatch
{
private const float ThirdPhaseHpThreshold = 0.1f;
private const float FleeArrivalDistance = 4f;
private static readonly FieldInfo RigField = AccessTools.Field(typeof(Item), "_rig");
private static readonly FieldInfo IsFlyingField = AccessTools.Field(typeof(BowheadWhale), "_isFlying");
private static readonly FieldInfo IsShootingLavaField = AccessTools.Field(typeof(BowheadWhale), "_isShootingLava");
private static readonly FieldInfo ShootLavaChanceField = AccessTools.Field(typeof(BowheadWhale), "_shootLavaChance");
private static readonly FieldInfo LavaCountField = AccessTools.Field(typeof(BowheadWhale), "_lavaCount");
private static readonly FieldInfo JumpsLeftField = AccessTools.Field(typeof(BowheadWhale), "_jumpsLeft");
private static readonly FieldInfo FlyForceTowardsPlayerField = AccessTools.Field(typeof(BowheadWhale), "_flyForceTowardsPlayer");
private static readonly MethodInfo ShootLavaMethod = AccessTools.Method(typeof(BowheadWhale), "ShootLava", (Type[])null, (Type[])null);
private static readonly MethodInfo FlyMethod = AccessTools.Method(typeof(BowheadWhale), "Fly", (Type[])null, (Type[])null);
private static readonly MethodInfo OnLandedMethod = AccessTools.Method(typeof(BowheadWhale), "OnLanded", (Type[])null, (Type[])null);
private const float MaxFallSeconds = 4f;
[HarmonyPatch("Awake")]
[HarmonyPostfix]
private static void AfterAwake(BowheadWhale __instance)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
ThirdPhaseState thirdPhaseState = ThirdPhaseState.Get(__instance);
if (!thirdPhaseState.SpawnPositionCaptured)
{
thirdPhaseState.SpawnPosition = ((Component)__instance).transform.position;
thirdPhaseState.SpawnPositionCaptured = true;
}
}
[HarmonyPatch("OnHealthChange")]
[HarmonyPostfix]
private static void AfterHealthChange(BowheadWhale __instance, int next, bool asServer)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Invalid comparison between Unknown and I4
if (!asServer || (int)((Creature)__instance).BossType != 2)
{
return;
}
ThirdPhaseState thirdPhaseState = ThirdPhaseState.Get(__instance);
if (!thirdPhaseState.PhaseActive && !thirdPhaseState.Resolved)
{
float num = (float)next / (float)BossManager.BossMaxHp;
if (num > 0f && num <= 0.1f)
{
thirdPhaseState.PhaseActive = true;
JumpsLeftField.SetValue(__instance, 1);
}
}
}
[HarmonyPatch("InitializeMovement")]
[HarmonyPrefix]
private static bool BeforeInitializeMovement(BowheadWhale __instance)
{
ThirdPhaseState thirdPhaseState = ThirdPhaseState.Get(__instance);
if (!thirdPhaseState.PhaseActive || thirdPhaseState.Resolved)
{
return true;
}
if (!(bool)IsFlyingField.GetValue(__instance))
{
JumpsLeftField.SetValue(__instance, 1);
FlyMethod.Invoke(__instance, null);
}
if (!(bool)IsShootingLavaField.GetValue(__instance))
{
float num = (float)ShootLavaChanceField.GetValue(__instance);
if (Random.Range(0f, 1f) <= num)
{
int num2 = (int)LavaCountField.GetValue(__instance);
((MonoBehaviour)__instance).StartCoroutine((IEnumerator)ShootLavaMethod.Invoke(__instance, new object[1] { num2 }));
}
}
return false;
}
[HarmonyPatch("UpdateMovement")]
[HarmonyPostfix]
private static void AfterUpdateMovement(BowheadWhale __instance)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: 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_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
ThirdPhaseState thirdPhaseState = ThirdPhaseState.Get(__instance);
if (!thirdPhaseState.PhaseActive || thirdPhaseState.Resolved || !thirdPhaseState.SpawnPositionCaptured || !((NetworkBehaviour)__instance).IsServerInitialized)
{
return;
}
object? value = RigField.GetValue(__instance);
Rigidbody val = (Rigidbody)((value is Rigidbody) ? value : null);
if ((Object)(object)val == (Object)null)
{
return;
}
Vector3 val2 = thirdPhaseState.SpawnPosition - val.worldCenterOfMass;
val2.y = 0f;
float magnitude = ((Vector3)(ref val2)).magnitude;
Vector3 val3 = thirdPhaseState.SpawnPosition - val.worldCenterOfMass;
if (((Vector3)(ref val3)).magnitude <= 4f)
{
thirdPhaseState.Resolved = true;
((NetworkBehaviour)__instance).Despawn(((Component)__instance).gameObject, (DespawnType?)null);
}
else if ((bool)IsFlyingField.GetValue(__instance) && !(magnitude < 0.01f))
{
Vector3 val4 = val2 / magnitude;
Vector3 linearVelocity = val.linearVelocity;
Vector2 val5 = new Vector2(linearVelocity.x, linearVelocity.z);
float num = ((Vector2)(ref val5)).magnitude;
float num2 = (float)FlyForceTowardsPlayerField.GetValue(__instance) * 0.5f;
if (num < num2)
{
num = num2;
}
Vector3 val6 = val4 * num;
val.linearVelocity = new Vector3(val6.x, linearVelocity.y, val6.z);
}
}
[HarmonyPatch("SetFlying")]
[HarmonyPostfix]
private static void AfterSetFlying(BowheadWhale __instance)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
ThirdPhaseState thirdPhaseState = ThirdPhaseState.Get(__instance);
if (!thirdPhaseState.PhaseActive || thirdPhaseState.Resolved)
{
return;
}
if (!(bool)IsFlyingField.GetValue(__instance))
{
thirdPhaseState.IsDescending = false;
return;
}
object? value = RigField.GetValue(__instance);
Rigidbody val = (Rigidbody)((value is Rigidbody) ? value : null);
if (!((Object)(object)val == (Object)null))
{
if (!(val.linearVelocity.y < -1f))
{
thirdPhaseState.IsDescending = false;
}
else if (!thirdPhaseState.IsDescending)
{
thirdPhaseState.IsDescending = true;
thirdPhaseState.DescendStartTime = Time.time;
}
else if (Time.time - thirdPhaseState.DescendStartTime >= 4f)
{
thirdPhaseState.IsDescending = false;
OnLandedMethod.Invoke(__instance, null);
}
}
}
[HarmonyPatch("OnLanded")]
[HarmonyPostfix]
private static void AfterOnLanded(BowheadWhale __instance)
{
//IL_001e: 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_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: 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_004b: 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_0059: 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_005f: 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)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
ThirdPhaseState thirdPhaseState = ThirdPhaseState.Get(__instance);
if (!thirdPhaseState.PhaseActive || thirdPhaseState.Resolved)
{
return;
}
Vector3 position = ((Component)__instance).transform.position;
if (!(position.y > WaterManager.WaterHeight + 1f))
{
for (int i = 0; i < 6; i++)
{
Vector3 val = Random.insideUnitSphere * 4f;
val.y = 0f;
Vector3 val2 = position + val;
val2.y = WaterManager.WaterHeight;
VFXManager.Play("WaterSplash", val2, Vector3.zero);
}
}
}
}
internal sealed class ThirdPhaseState
{
public Vector3 SpawnPosition;
public bool SpawnPositionCaptured;
public bool PhaseActive;
public bool Resolved;
public bool IsDescending;
public float DescendStartTime = -1f;
private static readonly ConditionalWeakTable<BowheadWhale, ThirdPhaseState> States = new ConditionalWeakTable<BowheadWhale, ThirdPhaseState>();
public static ThirdPhaseState Get(BowheadWhale whale)
{
return States.GetOrCreateValue(whale);
}
}
}
