using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalAmpUp.Patches;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("LethalAmpUp")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LethalAmpUp")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("295e10bc-e4fe-4a3a-8cc1-c352b4c3f427")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LethalAmpUp
{
[BepInPlugin("Janimates.LethalAmpUp", "LethalAmpUp", "1.0.0")]
public class LethalAmpUpBase : BaseUnityPlugin
{
private const string modGUID = "Janimates.LethalAmpUp";
private const string modName = "LethalAmpUp";
private const string modVersion = "1.0.0";
private readonly Harmony harmony = new Harmony("Janimates.LethalAmpUp");
private static LethalAmpUpBase Instance;
internal ManualLogSource mls;
public static ConfigEntry<bool> EnableModifiers;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
EnableModifiers = ((BaseUnityPlugin)this).Config.Bind<bool>("LAU Additions", "LAU Modifications", false, "(NOT FINISHED) Adds unique modifiers similar to BrutalCompany!");
mls = Logger.CreateLogSource("Janimates.LethalAmpUp");
mls.LogInfo((object)"Amping the mod!");
harmony.PatchAll(typeof(LethalAmpUpBase));
harmony.PatchAll(typeof(RadMechAIBPatch));
harmony.PatchAll(typeof(NutCrackerAIBPatch));
harmony.PatchAll(typeof(MouthDogAIBPatch));
harmony.PatchAll(typeof(ButlerAIBPatch));
harmony.PatchAll(typeof(FlashlightBPatch));
harmony.PatchAll(typeof(BunkerSpiderAIBPatch));
harmony.PatchAll(typeof(ClaySurgeonAIBPatch));
harmony.PatchAll(typeof(GhostGirlAIBPatch));
harmony.PatchAll(typeof(FlowerManAIBPatch));
harmony.PatchAll(typeof(EnemyAIBPatch));
harmony.PatchAll(typeof(SnareFleaAIBPatch));
harmony.PatchAll(typeof(HoardingBugAIBPatch));
harmony.PatchAll(typeof(DoubleWingAIBPatch));
harmony.PatchAll(typeof(ThumperAIBPatch));
harmony.PatchAll(typeof(StartOfRoundBPatch));
harmony.PatchAll(typeof(ForestGiantAIBPatch));
}
}
}
namespace LethalAmpUp.Patches
{
[HarmonyPatch(typeof(BlobAI))]
internal class BlobAIBPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void BlobAIAmplify(ref BlobAI __instance)
{
((EnemyAI)__instance).enemyType.pushPlayerForce = 5f;
}
}
[HarmonyPatch(typeof(SandSpiderAI))]
internal class BunkerSpiderAIBPatch
{
public static Dictionary<SandSpiderAI, float> SpiderSpeedBoosts = new Dictionary<SandSpiderAI, float>();
private static readonly float BASE_SPIDER_SPEED = -1.25f;
private static readonly float MAX_SPIDER_SPEED = 12.5f;
[HarmonyPatch(typeof(SandSpiderAI), "Start")]
[HarmonyPostfix]
private static void SpiderStart(ref SandSpiderAI __instance)
{
if (!SpiderSpeedBoosts.ContainsKey(__instance))
{
SpiderSpeedBoosts.Add(__instance, BASE_SPIDER_SPEED);
}
}
[HarmonyPatch(typeof(SandSpiderAI), "OnCollideWithPlayer")]
[HarmonyPrefix]
private static void SpiderDamagePlayer(ref SandSpiderAI __instance, ref Collider other, ref bool ___onWall, ref bool ___spoolingPlayerBody, ref float ___timeSinceHittingPlayer)
{
if (SpiderSpeedBoosts.ContainsKey(__instance) && !(((EnemyAI)__instance).isEnemyDead | ___onWall) && !((Object)(object)((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, ___spoolingPlayerBody, false) == (Object)null) && !(___timeSinceHittingPlayer <= 1f))
{
SpiderSpeedBoosts[__instance] += Random.Range(0.5f, 1.5f);
}
}
[HarmonyPatch("OnCollideWithPlayer")]
[HarmonyPrefix]
private static bool OnCollideWithPlayer(ref SandSpiderAI __instance, ref Collider other)
{
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
if (((EnemyAI)__instance).isEnemyDead && Traverse.Create((object)__instance).Field("onWall").GetValue<bool>())
{
return false;
}
PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, Traverse.Create((object)__instance).Field("SpoolingPlayerBody").GetValue<bool>(), false);
if ((Object)(object)val != (Object)null && Traverse.Create((object)__instance).Field("timeSinceHittingPlayer").GetValue<float>() > 0.5f)
{
Traverse.Create((object)__instance).Field("timeSinceHittingPlayer").SetValue((object)0f);
val.DamagePlayer(25, true, true, (CauseOfDeath)6, 0, false, default(Vector3));
__instance.HitPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
}
return false;
}
[HarmonyPatch(typeof(SandSpiderAI), "StopChasing")]
[HarmonyPostfix]
private static void ResetSpeed(ref SandSpiderAI __instance)
{
if (SpiderSpeedBoosts.ContainsKey(__instance))
{
SpiderSpeedBoosts[__instance] = BASE_SPIDER_SPEED;
}
}
[HarmonyPatch(typeof(SandSpiderAI), "Update")]
[HarmonyPostfix]
private static void SpiderUpdate(ref SandSpiderAI __instance)
{
if (SpiderSpeedBoosts.ContainsKey(__instance) && ((NetworkBehaviour)__instance).IsOwner && !(((EnemyAI)__instance).stunNormalizedTimer > 0f) && SpiderSpeedBoosts[__instance] != 0f)
{
((EnemyAI)__instance).agent.speed = Mathf.Clamp(((EnemyAI)__instance).agent.speed + SpiderSpeedBoosts[__instance], 0f, MAX_SPIDER_SPEED);
__instance.spiderSpeed = Mathf.Clamp(__instance.spiderSpeed + SpiderSpeedBoosts[__instance], 0f, MAX_SPIDER_SPEED);
}
}
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void BunkerSpiderAmp(ref SandSpiderAI __instance)
{
((EnemyAI)__instance).enemyHP = 6;
}
}
[HarmonyPatch(typeof(ButlerEnemyAI))]
internal class ButlerAIBPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void ButlerAmplify(ref ButlerEnemyAI __instance)
{
__instance.idleMovementSpeedBase = 10f;
((EnemyAI)__instance).enemyHP = 10;
((EnemyAI)__instance).enemyType.MaxCount = 1;
((EnemyAI)__instance).enemyType.PowerLevel = 3f;
}
[HarmonyPatch("OnCollideWithPlayer")]
[HarmonyPrefix]
private static bool ButlerCollidePatch(ref ButlerEnemyAI __instance, ref Collider other)
{
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
if (((EnemyAI)__instance).isEnemyDead)
{
return false;
}
if (((EnemyAI)__instance).currentBehaviourStateIndex != 2 && Random.Range(0, 100) >= 100)
{
return false;
}
if (Traverse.Create((object)__instance).Field("timeSinceHittingPlayer").GetValue<float>() < 0.167f)
{
return false;
}
PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)GameNetworkManager.Instance.localPlayerController)
{
return false;
}
Traverse.Create((object)__instance).Field("timeSinceHittingPlayer").SetValue((object)0f);
if (((EnemyAI)__instance).currentBehaviourStateIndex != 2)
{
Traverse.Create((object)__instance).Field("berserkModeTimer").SetValue((object)60f);
}
val.DamagePlayer(5, true, true, (CauseOfDeath)14, 0, false, default(Vector3));
__instance.StabPlayerServerRpc((int)val.playerClientId, true);
return false;
}
}
[HarmonyPatch(typeof(ClaySurgeonAI))]
internal class ClaySurgeonAIBPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void ClaySurgeonAmplify(ref ClaySurgeonAI __instance)
{
__instance.jumpSpeed = 7f;
__instance.jumpTime = 1f;
__instance.startingInterval = 1.5f;
__instance.endingInterval = 0.15f;
}
}
[HarmonyPatch(typeof(SpringManAI))]
internal class CoilHeadAIBPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void CoilheadAIAmplify(ref SpringManAI __instance)
{
((EnemyAI)__instance).enemyType.MaxCount = 2;
Traverse.Create((object)__instance).Field("currentChaseSpeed").SetValue((object)5);
}
}
[HarmonyPatch(typeof(DoublewingAI))]
internal class DoubleWingAIBPatch
{
[HarmonyPatch("AlertBird")]
[HarmonyPrefix]
private static void DoubleWingExplosive(ref DoublewingAI __instance)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
Landmine.SpawnExplosion(((Component)__instance).transform.position, true, 0f, 10f, 0, 30f, (GameObject)null, false);
}
}
[HarmonyPatch(typeof(BaboonBirdAI))]
internal class DumbIdiotsAIBPatch
{
}
[HarmonyPatch(typeof(EnemyAI))]
internal class EnemyAIBPatch
{
[HarmonyPatch(typeof(EnemyAI), "ReachedNodeInSearch")]
[HarmonyPostfix]
private static void EnemyReachedNode(ref EnemyAI __instance)
{
if (__instance is SandWormAI)
{
SandWormReachedNode(((Component)__instance).GetComponent<SandWormAI>());
}
else if (__instance is RadMechAI)
{
RadMechReachedNode(((Component)__instance).GetComponent<RadMechAI>());
}
}
private static void SandWormReachedNode(SandWormAI worm)
{
if (!((Object)(object)worm == (Object)null) && !((EnemyAI)worm).isEnemyDead && StartOfRound.Instance.livingPlayers != 0 && ((EnemyAI)worm).currentBehaviourStateIndex == 0 && !worm.inEmergingState && Random.Range(0, 100) < 97)
{
worm.StartEmergeAnimation();
}
}
private static void RadMechReachedNode(RadMechAI mech)
{
if (!((Object)(object)mech == (Object)null) && !((EnemyAI)mech).isEnemyDead)
{
if (Random.Range(0, 100) >= 90)
{
mech.FlickerFace();
return;
}
if (Random.Range(0, 100) >= 95)
{
mech.EnableSpotlight();
return;
}
if (Random.Range(0, 100) >= 95)
{
mech.EnableBlowtorch();
return;
}
mech.DisableSpotlight();
mech.DisableBlowtorch();
}
}
}
[HarmonyPatch(typeof(FlashlightItem))]
internal class FlashlightBPatch
{
private static AudioClip[] sprayCanSFX;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void FlashLightChanges(ref FlashlightItem __instance)
{
if (__instance.flashlightTypeID == 1)
{
((GrabbableObject)__instance).itemProperties.batteryUsage = 15f;
((GrabbableObject)__instance).useCooldown = 0.25f;
((GrabbableObject)__instance).insertedBattery.charge = 0f;
if (sprayCanSFX == null)
{
sprayCanSFX = Resources.FindObjectsOfTypeAll<SprayPaintItem>().First().sprayCanShakeSFX;
}
}
}
[HarmonyPatch("EquipItem")]
[HarmonyPostfix]
private static void EquipFlashlightPatch(ref FlashlightItem __instance)
{
if (__instance.flashlightTypeID == 1)
{
((GrabbableObject)__instance).insertedBattery.empty = false;
}
}
[HarmonyPatch("ItemActivate")]
[HarmonyPrefix]
private static bool ItemActivateChange(ref FlashlightItem __instance)
{
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
if (__instance.flashlightTypeID != 1)
{
return true;
}
__instance.flashlightAudio.PlayOneShot(sprayCanSFX[Random.Range(0, sprayCanSFX.Length)]);
((GrabbableObject)__instance).insertedBattery.charge = Mathf.Clamp01(((GrabbableObject)__instance).insertedBattery.charge + 0.12f);
PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
if (playerHeldBy != null)
{
playerHeldBy.playerBodyAnimator.SetBool("Grab", true);
}
((GrabbableObject)__instance).insertedBattery.empty = false;
((GrabbableObject)__instance).SyncBatteryServerRpc((int)(((GrabbableObject)__instance).insertedBattery.charge * 100f));
__instance.SwitchFlashlight(true);
RoundManager.Instance.PlayAudibleNoise(((Component)__instance).transform.position, 22f, 0.6f, 0, ((GrabbableObject)__instance).isInShipRoom && StartOfRound.Instance.hangarDoorsClosed, 0);
return false;
}
[HarmonyPatch("UseUpBatteries")]
[HarmonyPostfix]
private static void UseUpBatteriesPatch(ref FlashlightItem __instance)
{
if (__instance.flashlightTypeID == 1)
{
((GrabbableObject)__instance).insertedBattery.empty = false;
}
}
}
[HarmonyPatch(typeof(FlowermanAI))]
internal class FlowerManAIBPatch
{
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void BrackenAIAmplify(ref FlowermanAI __instance)
{
if (!((EnemyAI)__instance).isEnemyDead && !__instance.inKillAnimation && !((Object)(object)GameNetworkManager.Instance == (Object)null) && ((EnemyAI)__instance).currentBehaviourStateIndex == 0)
{
((EnemyAI)__instance).agent.speed = 1f;
}
}
}
[HarmonyPatch(typeof(ForestGiantAI))]
internal class ForestGiantAIBPatch
{
public static List<ForestGiantAI> BlindGiants = new List<ForestGiantAI>();
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void GiantAmplify(ref ForestGiantAI __instance)
{
if (Random.Range(0, 100) < 85 && !BlindGiants.Contains(__instance))
{
MakeGiantBlind(__instance);
}
}
[HarmonyPatch("LookForPlayers")]
[HarmonyPrefix]
private static bool GiantDoesNotSearch(ref ForestGiantAI __instance)
{
return !BlindGiants.Contains(__instance);
}
[HarmonyPatch(typeof(ForestGiantAI), "Update")]
[HarmonyPostfix]
private static void BlindBuff(ref ForestGiantAI __instance)
{
if (BlindGiants.Contains(__instance) && !(((EnemyAI)__instance).stunNormalizedTimer > 0f))
{
((EnemyAI)__instance).agent.speed = 8.5f;
}
}
private static void MakeGiantBlind(ForestGiantAI giant)
{
if (!BlindGiants.Contains(giant))
{
ScanNodeProperties componentInChildren = ((Component)giant).GetComponentInChildren<ScanNodeProperties>();
if (!((Object)(object)componentInChildren == (Object)null))
{
BlindGiants.Add(giant);
componentInChildren.headerText = "Blind Giant";
componentInChildren.subText = "Fast, But Blind.";
}
}
}
[HarmonyPatch(typeof(EnemyAI), "SetEnemyStunned")]
[HarmonyPostfix]
private static void GiantStunned(ref EnemyAI __instance)
{
if (Random.Range(0, 100) < 97)
{
ForestGiantAI component = ((Component)__instance).GetComponent<ForestGiantAI>();
if (!((Object)(object)component == (Object)null) && !BlindGiants.Contains(component))
{
MakeGiantBlind(component);
}
}
}
}
[HarmonyPatch(typeof(DressGirlAI))]
internal class GhostGirlAIBPatch
{
[HarmonyPatch("ChoosePlayerToHaunt")]
[HarmonyPostfix]
private static void GhostGirlHauntAmp(ref DressGirlAI __instance)
{
Traverse.Create((object)__instance).Field("timesStared").SetValue((object)999);
Traverse.Create((object)__instance).Field("timesSeenByPlayer").SetValue((object)5);
if (Random.Range(0, 100) < 50)
{
BreakerBox val = Object.FindObjectOfType<BreakerBox>();
if (!((Object)(object)val == (Object)null))
{
val.SetSwitchesOff();
RoundManager.Instance.TurnOnAllLights(false);
}
}
}
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void GhostGirlAmp(ref DressGirlAI __instance)
{
}
}
[HarmonyPatch(typeof(HoarderBugAI))]
internal class HoardingBugAIBPatch
{
[HarmonyPatch(typeof(HoarderBugAI), "Update")]
[HarmonyPostfix]
private static void HoarderSpeedPatch(ref HoarderBugAI __instance)
{
if (((EnemyAI)__instance).currentBehaviourStateIndex == 1 && !(((EnemyAI)__instance).stunNormalizedTimer > 0f) && __instance.heldItem != null)
{
((EnemyAI)__instance).agent.speed = 20f;
}
}
}
[HarmonyPatch(typeof(MouthDogAI))]
internal class MouthDogAIBPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void MouthDogAmplify(ref MouthDogAI __instance)
{
}
[HarmonyPatch("Update")]
[HarmonyPrefix]
private static void UpdatePatch(ref MouthDogAI __instance)
{
if (((NetworkBehaviour)__instance).IsOwner && ((EnemyAI)__instance).currentBehaviourStateIndex == 3 && !(((EnemyAI)__instance).agent.speed > 10f) && !__instance.endingLunge && !Traverse.Create((object)__instance).Field("inKillAnimation").GetValue<bool>())
{
__instance.endingLunge = true;
Traverse.Create((object)__instance).Field("lungeCooldown").SetValue((object)0.15f);
__instance.EndLungeServerRpc();
}
}
}
[HarmonyPatch(typeof(NutcrackerEnemyAI))]
internal class NutCrackerAIBPatch
{
public static List<NutcrackerEnemyAI> Alphred = new List<NutcrackerEnemyAI>();
[HarmonyPatch("TurnTorsoToTargetDegrees")]
[HarmonyPrefix]
private static void IncreaseSpeed(ref NutcrackerEnemyAI __instance)
{
NutcrackerEnemyAI obj = __instance;
obj.torsoTurnSpeed *= 3f;
}
[HarmonyPatch("TurnTorsoToTargetDegrees")]
[HarmonyPostfix]
private static void RevertSpeed(ref NutcrackerEnemyAI __instance)
{
NutcrackerEnemyAI obj = __instance;
obj.torsoTurnSpeed /= 3f;
}
[HarmonyPatch("GlobalNutcrackerClock")]
[HarmonyPrefix]
private static bool ReplaceClockFunction(ref NutcrackerEnemyAI __instance)
{
if (!Traverse.Create((object)__instance).Field("isLeaderScript").GetValue<bool>())
{
return false;
}
if (Time.realtimeSinceStartup - NutcrackerEnemyAI.timeAtNextInspection <= 2f)
{
return false;
}
NutcrackerEnemyAI.timeAtNextInspection = Time.realtimeSinceStartup + (float)Random.Range(3, 6);
return false;
}
[HarmonyPatch("ReloadGun")]
[HarmonyPostfix]
private static void ReloadDefense(ref NutcrackerEnemyAI __instance)
{
//IL_001f: 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_0069: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
if (Random.Range(0, 100) >= 99)
{
Landmine.SpawnExplosion(((Component)__instance).transform.position, true, 0f, 15f, 0, 30f, (GameObject)null, false);
Landmine.SpawnExplosion(((Component)__instance).transform.position, true, 0f, 15f, 5, 30f, (GameObject)null, false);
Landmine.SpawnExplosion(((Component)__instance).transform.position, true, 0f, 15f, 10, 30f, (GameObject)null, false);
Landmine.SpawnExplosion(((Component)__instance).transform.position, true, 0f, 15f, 15, 30f, (GameObject)null, false);
Landmine.SpawnExplosion(((Component)__instance).transform.position, true, 0f, 15f, 20, 30f, (GameObject)null, false);
}
}
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void AlphredNut(ref NutcrackerEnemyAI __instance)
{
if (Random.Range(0, 100) > 99 && !Alphred.Contains(__instance))
{
ScanNodeProperties componentInChildren = ((Component)__instance).GetComponentInChildren<ScanNodeProperties>();
if (!((Object)(object)componentInChildren == (Object)null))
{
Alphred.Add(__instance);
componentInChildren.headerText = "Alphred";
componentInChildren.subText = "He's Alphred.";
((EnemyAI)__instance).enemyHP = 6;
}
}
}
}
[HarmonyPatch(typeof(RadMechAI))]
internal class RadMechAIBPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void RadMechAmplify(ref RadMechAI __instance)
{
RadMechAI obj = __instance;
obj.fireRate *= 0.5f;
RadMechAI obj2 = __instance;
obj2.missileSpeed *= 3f;
AISearchRoutine searchForPlayers = __instance.searchForPlayers;
searchForPlayers.searchWidth /= 1.5f;
RadMechAI obj3 = __instance;
obj3.chargeForwardSpeed *= 1.5f;
}
}
[HarmonyPatch(typeof(RoundManager))]
internal class RoundManagerBPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void ExtraRoundManagerStuff(ref RoundManager __instance)
{
}
}
[HarmonyPatch(typeof(CentipedeAI))]
internal class SnareFleaAIBPatch
{
[HarmonyPatch("OnCollideWithPlayer")]
[HarmonyPrefix]
private static bool CancelCollide()
{
return false;
}
[HarmonyPatch("fallFromCeiling")]
[HarmonyPrefix]
private static bool FleaFallFromCeilingPatch(ref CentipedeAI __instance, ref IEnumerator __result)
{
__result = FleaFallFromCeiling(__instance);
return false;
}
private static IEnumerator FleaFallFromCeiling(CentipedeAI flea)
{
((EnemyAI)flea).targetNode = null;
Vector3 start = ((Component)flea).transform.position;
Vector3 ground = ((Component)flea).transform.position;
Ray ray = new Ray(((Component)flea).transform.position, Vector3.down);
RaycastHit hit = default(RaycastHit);
if (!Physics.Raycast(ray, ref hit, 20f, 268435712))
{
start = RoundManager.Instance.GetNavMeshPosition(((Ray)(ref ray)).GetPoint(4f), default(NavMeshHit), 7f, -1);
if (((NetworkBehaviour)flea).IsOwner)
{
((EnemyAI)flea).KillEnemyOnOwnerClient(true);
}
}
else
{
ground = ((RaycastHit)(ref hit)).point;
}
float fallTime = 0f;
float fallSpeed = 2.5f;
while (fallTime < 1f)
{
yield return null;
fallTime += Time.deltaTime * fallSpeed;
((Component)flea).transform.position = Vector3.Lerp(start, ground, flea.fallToGroundCurve.Evaluate(fallTime));
}
((EnemyAI)flea).creatureSFX.PlayOneShot(flea.hitGroundSFX);
((EnemyAI)flea).serverPosition = ((Component)flea).transform.position;
if (((NetworkBehaviour)flea).IsOwner)
{
((EnemyAI)flea).agent.speed = 0f;
}
else
{
((Component)flea).transform.eulerAngles = new Vector3(0f, ((Component)flea).transform.eulerAngles.y, 0f);
}
Traverse.Create((object)flea).Field("clingingToCeiling").SetValue((object)false);
((EnemyAI)flea).inSpecialAnimation = false;
yield return (object)new WaitForSeconds(0.2f);
Landmine.SpawnExplosion(((Component)flea).transform.position, true, 0f, 3f, 45, 25f, (GameObject)null, false);
Traverse.Create((object)flea).Field("ceilingAnimationCoroutine").SetValue((object)null);
Traverse.Create((object)flea).Field("startedCeilingAnimationCoroutine").SetValue((object)false);
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class StartOfRoundBPatch
{
public static Dictionary<SandSpiderAI, float> SpiderSpeedBoosts = new Dictionary<SandSpiderAI, float>();
public static List<ForestGiantAI> BlindGiants = new List<ForestGiantAI>();
public static List<NutcrackerEnemyAI> Alphred = new List<NutcrackerEnemyAI>();
[HarmonyPatch(typeof(StartOfRound), "StartGame")]
[HarmonyPrefix]
private static void StartGamePatch()
{
SpiderSpeedBoosts.Clear();
BlindGiants.Clear();
Alphred.Clear();
}
}
[HarmonyPatch(typeof(CrawlerAI))]
internal class ThumperAIBPatch
{
[HarmonyPatch("MakeScreech")]
[HarmonyPrefix]
private static bool NoMoreScreech(ref CrawlerAI __instance)
{
//IL_0010: 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)
if (Vector3.Distance(((Component)GameNetworkManager.Instance.localPlayerController).transform.position, ((Component)__instance).transform.position) < 15f)
{
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(0.75f, true);
}
return false;
}
[HarmonyPatch("OnCollideWithPlayer")]
[HarmonyPrefix]
private static bool OnCollideWithPlayerThump(ref CrawlerAI __instance, ref Collider other)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
if (!(Traverse.Create((object)__instance).Field("timeSinceHittingPlayer").GetValue<float>() < 0.2f))
{
PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, false, false);
if ((Object)(object)val != (Object)null)
{
Traverse.Create((object)__instance).Field("timeSinceHittingPlayer").SetValue((object)0);
val.DamagePlayer(10, true, true, (CauseOfDeath)6, 0, false, default(Vector3));
((EnemyAI)__instance).agent.speed = 0f;
__instance.HitPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
GameNetworkManager.Instance.localPlayerController.JumpToFearLevel(1f, true);
}
}
return false;
}
[HarmonyPatch("EatPlayerBodyAnimation")]
[HarmonyPrefix]
private static void ExplodeOnSuccess(ref CrawlerAI __instance)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
Landmine.SpawnExplosion(((Component)__instance).transform.position, true, 0f, 10f, 15, 55f, (GameObject)null, false);
}
}
}
