using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using AIGraph;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BetterBots.Attributes;
using BetterBots.Components;
using BetterBots.Data;
using BetterBots.Managers;
using BetterBots.PlayerBotActionDebugs;
using BetterBots.Utils;
using ChainedPuzzles;
using Enemies;
using GameData;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using LevelGeneration;
using Player;
using SNetwork;
using UnityEngine;
using UnityEngine.AI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BetterBots")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterBots")]
[assembly: AssemblyCopyright("Copyright © 2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("84385dfb-6568-471f-998e-58f5a2c9754e")]
[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 BetterBots
{
[BepInPlugin("com.east.bb", "BetterBots", "0.0.8")]
public class BetterBots : BasePlugin
{
public static class Settings
{
public static readonly float ADDITIONAL_BULLET_DAMAGE;
public static readonly float DAMAGE_RESISTANCE_MULTIPLIER;
}
public static Harmony HarmonyMain;
public const string GUID = "com.east.bb";
public const string Name = "BetterBots";
public const string Version = "0.0.8";
public override void Load()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
BBLog.Message("<<<<---------Launcing Better Bots------------>>>");
new Harmony("com.east.bb").PatchAll();
}
public static void OnStartGame()
{
BBLog.Message("<<<<---------OnStartGame Better Bots------------>>>");
LaunchComponents();
OnStarted();
}
private static void OnStarted()
{
ConfigurationPluginManager.Initialized();
}
private static void LaunchComponents()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
foreach (Type type in types)
{
if (!(type.BaseType != null))
{
continue;
}
Type typeFromHandle = typeof(MonoBehaviorFixed);
if (!(type.BaseType == typeFromHandle) && !typeFromHandle.IsSubclassOf(typeFromHandle))
{
continue;
}
ClassInjector.RegisterTypeInIl2Cpp(type);
IL2CPP_ComponentDescriptorAttribute customAttribute = type.GetCustomAttribute<IL2CPP_ComponentDescriptorAttribute>();
if (customAttribute != null && customAttribute.m_launchOnStartLoad)
{
GameObject val = new GameObject();
val.AddComponent(Il2CppType.From(type));
BBLog.Message("Adding Component " + type);
if (customAttribute.m_dontDestroyOnLoad)
{
Object.DontDestroyOnLoad((Object)(object)val);
}
}
}
}
}
}
namespace BetterBots.Utils
{
public static class BBLog
{
private static readonly ManualLogSource logger;
private static bool m_enableDebugs;
static BBLog()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
logger = new ManualLogSource("BETTER-BETTER-IMPROVED");
m_enableDebugs = true;
Logger.Sources.Add((ILogSource)(object)logger);
}
public static void Verbose(object msg)
{
logger.LogInfo(msg);
}
public static void Debug(object msg)
{
if (m_enableDebugs)
{
logger.LogDebug(msg);
}
}
public static void Message(object msg)
{
if (m_enableDebugs)
{
logger.LogMessage(msg);
}
}
public static void Error(object msg)
{
if (m_enableDebugs)
{
logger.LogError(msg);
}
}
public static void Warn(object msg)
{
if (m_enableDebugs)
{
logger.LogWarning(msg);
}
}
}
public static class CppUtils
{
public static List<T> ToList<T>(this List<T> cppList)
{
List<T> list = new List<T>();
for (int i = 0; i < cppList.Count; i++)
{
list.Add(cppList[i]);
}
return list;
}
}
public static class PlayerAgentExtraExtensions
{
public static bool CanSeePosition(this PlayerAgent player, Vector3 eyePos, Vector3 targetPos, int layerMask, out RaycastHit hitInfo)
{
//IL_0002: 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_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_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: 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_0029: 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_0032: Unknown result type (might be due to invalid IL or missing references)
Ray val = default(Ray);
((Ray)(ref val)).origin = eyePos;
Ray val2 = val;
Vector3 val3 = targetPos - eyePos;
float magnitude = ((Vector3)(ref val3)).magnitude;
val3 = (((Ray)(ref val2)).direction = val3 / magnitude);
return !Physics.Raycast(val2, ref hitInfo, magnitude, layerMask);
}
public static bool CanSeeObject(this PlayerAgent player, Vector3 eyePos, GameObject targetObj)
{
//IL_0006: 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_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)
Vector3 position = targetObj.transform.position;
if (!player.CanSeePosition(eyePos, position, LayerManager.MASK_WORLD, out var hitInfo) && (Object)(object)((Component)((RaycastHit)(ref hitInfo)).transform).gameObject != (Object)(object)targetObj)
{
return ((RaycastHit)(ref hitInfo)).transform.IsChildOf(targetObj.transform);
}
return true;
}
}
public static class TypeExtensions
{
public static bool IsTypeMonoBehaviorFixed(Type type)
{
if (type == typeof(MonoBehaviorFixed))
{
return true;
}
if (type.BaseType == typeof(MonoBehaviorFixed) || type.IsSubclassOf(typeof(MonoBehaviorFixed)))
{
return true;
}
return false;
}
}
}
namespace BetterBots.PlayerBotActionDebugs
{
public class PBAD_UseFireArm : PlayerBotActionDebug<PlayerBotActionUseFirearm>
{
protected override void PostAdditionalFields(PlayerBotActionUseFirearm action)
{
//IL_0017: 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_0041: 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_0070: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
bool flag = action.TestFriendlyFire();
AppendColorInformation("TestFriendlyFire", flag ? Color.green : Color.red, flag);
AppendColorInformation("OpenFire", action.m_desc.OpenFire ? Color.green : Color.red, action.m_desc.OpenFire);
AppendColorInformation("m_lookAction", (action.m_lookAction != null) ? Color.green : Color.red, (action.m_lookAction != null) ? "Active" : "Not Active");
AppendColorInformation("m_aimIsBlending", ((PlayerBotActionBase)action).m_agent.SyncIK.m_aimIsBlending ? Color.green : Color.red, ((PlayerBotActionBase)action).m_agent.SyncIK.m_aimIsBlending);
AppendColorInformation("requireVisibility", action.m_desc.requireVisibility ? Color.green : Color.red, "action.m_desc.requireVisibility");
}
}
public class PlayerBotActionDebug<PA> : PlayerBotActionDebugBase where PA : PlayerBotActionBase
{
public override Type ActionType => Il2CppType.Of<PA>();
public override string ActionName => ((MemberInfo)Il2CppType.Of<PA>()).Name;
public sealed override void PrintFields(PlayerBotActionBase m_actionBase)
{
base.PrintFields(m_actionBase);
PostAdditionalFields(((Il2CppObjectBase)m_actionBase).TryCast<PA>());
}
protected virtual void PostAdditionalFields(PA action)
{
}
}
public class PBAD_Attack : PlayerBotActionDebug<PlayerBotActionAttack>
{
protected override void PostAdditionalFields(PlayerBotActionAttack action)
{
//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)
//IL_0030: 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_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)
StanceEnum stance = action.m_desc.Stance;
AppendInformation("Posture", ((object)(StanceEnum)(ref stance)).ToString());
PostureEnum posture = action.m_desc.Posture;
AppendInformation("Stance", ((object)(PostureEnum)(ref posture)).ToString());
AppendInformation("Haste", "<color=orange>" + action.m_desc.Haste + "</color>");
AttackMeansEnum means = action.m_desc.Means;
AppendInformation("Means", "<color=#FFA8A8>" + ((object)(AttackMeansEnum)(ref means)).ToString() + "</color>");
}
}
public abstract class PlayerBotActionDebugBase
{
private string m_currentMessage;
public virtual Type ActionType => null;
public virtual string ActionName => "UNKNOWN";
public string Message => m_currentMessage;
public virtual void PrintFields(PlayerBotActionBase m_actionBase)
{
ResetMessage();
SetTitle(ActionName);
PrintBaseFields(m_actionBase);
}
protected void PrintBaseFields(PlayerBotActionBase m_actionBase)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
if (m_actionBase.m_descBase != null)
{
StatusType status = m_actionBase.m_descBase.Status;
AppendInformation("Status", ((object)(StatusType)(ref status)).ToString());
AppendInformation("Priority", "<color=orange>" + m_actionBase.m_descBase.Prio + "</color>");
}
else
{
ApendErrorInformation("Action Descriptor is null!!");
}
}
private void SetTitle(string title)
{
m_currentMessage = m_currentMessage + "\n\t" + title;
}
private void ResetMessage()
{
m_currentMessage = string.Empty;
}
protected void AppendInformation(string fieldName, string information)
{
m_currentMessage = m_currentMessage + "\n\t\t" + fieldName + " : " + information;
}
protected void AppendInformation(string fieldName, object informationObject)
{
AppendInformation(fieldName, informationObject.ToString());
}
protected void AppendColorInformation(string fieldName, Color color, string information)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
m_currentMessage = m_currentMessage + "\n\t\t" + fieldName + " : <color=#" + ColorUtility.ToHtmlStringRGBA(color) + ">" + information + "</color>";
}
protected void AppendColorInformation(string fieldName, Color color, object informationObj)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
AppendColorInformation(fieldName, color, informationObj.ToString());
}
protected void ApendErrorInformation(string information)
{
m_currentMessage = m_currentMessage + "\n\t\t<color=red>" + information + "</color>";
}
}
public class PBAD_CarryExpeditionItem : PlayerBotActionDebug<PlayerBotActionCarryExpeditionItem>
{
protected override void PostAdditionalFields(PlayerBotActionCarryExpeditionItem action)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: 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 (action.m_desc != null)
{
Color yellow = Color.yellow;
State state = action.m_state;
AppendColorInformation("State", yellow, ((object)(State)(ref state)).ToString());
if ((Object)(object)action.m_desc.TargetItem != (Object)null)
{
AppendInformation("TargetItem", "<color=yellow>" + ((Item)action.m_desc.TargetItem).PublicName + "</color>");
}
else
{
AppendInformation("TargetItem", "<color=red>NONE</color>");
}
AppendInformation("AllowIdleDrop", action.m_desc.AllowIdleDrop.ToString());
AppendInformation("MaxLeaderDistance", action.m_desc.MaxLeaderDistance.ToString());
AppendInformation("HoldPrio", action.m_desc.HoldPrio.ToString());
}
}
}
public class PBAD_Follow : PlayerBotActionDebug<PlayerBotActionFollow>
{
protected override void PostAdditionalFields(PlayerBotActionFollow action)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
State state = action.m_state;
AppendInformation("State", ((object)(State)(ref state)).ToString());
AppendInformation("Client", ((Object)action.m_desc.Client.Owner).ToString());
AppendInformation("MaxDistance", action.m_desc.MaxDistance.ToString());
AppendInformation("FormationPrio", action.m_desc.FormationPrio.ToString());
}
}
public class PBAD_CollectItem : PlayerBotActionDebug<PlayerBotActionCollectItem>
{
protected override void PostAdditionalFields(PlayerBotActionCollectItem action)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: 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)
State state = action.m_state;
AppendInformation("State", ((object)(State)(ref state)).ToString());
if ((Object)(object)action.m_desc.TargetItem != (Object)null)
{
AppendInformation("TargetItem", "<color=yellow>" + action.m_desc.TargetItem.PublicName + "</color>");
}
else
{
AppendInformation("TargetItem", "<color=red>NONE</color>");
}
if ((Object)(object)action.m_desc.TargetContainer != (Object)null)
{
eResourceContainerStatus status = action.m_desc.TargetContainer.m_core.Status;
AppendInformation("TargetContainer Status", ((object)(eResourceContainerStatus)(ref status)).ToString());
AppendInformation("TargetContainer Name", ((Object)action.m_desc.TargetContainer).name.ToString());
}
}
}
public class PBAD_Melee : PlayerBotActionDebug<PlayerBotActionMelee>
{
protected override void PostAdditionalFields(PlayerBotActionMelee action)
{
//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)
StateEnum state = action.m_desc.State;
AppendInformation("State", ((object)(StateEnum)(ref state)).ToString());
AppendInformation("Strike", action.m_desc.Strike.ToString());
AppendInformation("IsCharged", action.m_desc.IsCharged.ToString());
AppendInformation("ChargeDuraction", Mathf.Max(Time.time - action.m_chargeStartTime, 0f).ToString());
}
}
public class PBAD_UseBioScan : PlayerBotActionDebug<PlayerBotActionUseBioscan>
{
protected override void PostAdditionalFields(PlayerBotActionUseBioscan action)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
State state = action.m_state;
AppendInformation("State", ((object)(State)(ref state)).ToString());
}
}
public enum PlayerBotActionType
{
Idle,
Follow,
Attack,
Revive,
ShareResource,
UseBioScan,
CollectItem,
CarryExpedtionItem,
Melee,
UseFireArm
}
}
namespace BetterBots.Patches.ManualPatches
{
[HarmonyPatch(typeof(BulletWeapon))]
internal class Patch_BulletWeapon
{
[HarmonyPrefix]
[HarmonyPatch("BulletHit")]
private static bool Pre_BulletHit(ref WeaponHitData weaponRayData)
{
//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_0050: 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_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: 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)
if (SNet.IsMaster && ConfigurationPluginManager.BetterBotsAimBot && (Object)(object)weaponRayData.owner != (Object)null && weaponRayData.owner.Owner.IsBot)
{
if (PlayerBotManagerExtended.TryToHitEnemy(weaponRayData.owner, out var hitDir, out var raycastHit))
{
weaponRayData.fireDir = hitDir;
weaponRayData.rayHit = raycastHit;
}
weaponRayData.damage = PlayerBotManagerExtended.AddBonusMulitplier(weaponRayData.damage, BetterBots.Settings.ADDITIONAL_BULLET_DAMAGE);
RaycastHit rayHit = weaponRayData.rayHit;
if ((Object)(object)((RaycastHit)(ref rayHit)).collider != (Object)null)
{
rayHit = weaponRayData.rayHit;
if ((Object)(object)((Component)((RaycastHit)(ref rayHit)).collider).gameObject != (Object)null)
{
rayHit = weaponRayData.rayHit;
if ((Object)(object)((Component)((RaycastHit)(ref rayHit)).collider).gameObject.GetComponentInParent<PlayerAgent>() != (Object)null)
{
return false;
}
}
}
}
return true;
}
}
[HarmonyPatch(typeof(AgentModifierManager))]
internal class Patch_AgentModifierManager
{
[HarmonyPrefix]
[HarmonyPatch("ApplyModifier")]
private static void Pre_ApplyModifier(Agent agent, AgentModifier modifier, ref float value)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Invalid comparison between Unknown and I4
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Invalid comparison between Unknown and I4
if ((Object)(object)agent != (Object)null)
{
PlayerAgent val = ((Il2CppObjectBase)agent).TryCast<PlayerAgent>();
if ((Object)(object)val != (Object)null && (Object)(object)val.Owner != (Object)null && val.Owner.IsBot && ((int)modifier == 6 || (int)modifier == 7))
{
value = PlayerBotManagerExtended.SubtractBonusMulitplier(value, BetterBots.Settings.DAMAGE_RESISTANCE_MULTIPLIER);
}
}
}
}
[HarmonyPatch(typeof(DramaManager))]
internal class Patch_DramaManager
{
[HarmonyPostfix]
[HarmonyPatch("CheckLoudTransition")]
private static void PostCheckLoudTransition(DRAMA_State newState)
{
//IL_0002: 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_0006: Invalid comparison between Unknown and I4
bool hasLoudStateEnter = false;
if (newState - 5 <= 3)
{
hasLoudStateEnter = true;
}
PlayerBotManagerExtended.HasLoudStateEnter = hasLoudStateEnter;
}
}
[HarmonyPatch(typeof(PlayerAgent))]
internal class Patch_PlayerAgent
{
private const bool m_recordBot = true;
[HarmonyPostfix]
[HarmonyPatch("Setup")]
private static void PostSetup(PlayerAgent __instance)
{
if (__instance.Owner.IsBot && (Object)(object)((Component)__instance).gameObject.GetComponent<BotRecorder>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<BotRecorder>();
BBLog.Message("BotRecoder Setup for " + __instance.Owner.NickName);
}
}
}
[HarmonyPatch(typeof(PlayerAIBot))]
internal class Patch_PlayerAIBot
{
[HarmonyPostfix]
[HarmonyPatch("WantsCrouch")]
private static void Post_WantsToCrouch(PlayerAIBot __instance, ref bool __result)
{
BotRecorder component = ((Component)__instance.Agent).gameObject.GetComponent<BotRecorder>();
if ((Object)(object)component != (Object)null && component.SneakingRestricted)
{
__result = false;
}
}
[HarmonyPostfix]
[HarmonyPatch("HasTwitcherNearby")]
private static void Post_HasTwitcherNearby(PlayerAIBot __instance, ref bool __result)
{
BotRecorder component = ((Component)__instance.Agent).gameObject.GetComponent<BotRecorder>();
if ((Object)(object)component != (Object)null && component.SneakingRestricted)
{
__result = false;
}
}
}
[HarmonyPatch(typeof(PlayerBotActionAttack))]
internal class Patch_PlayerBotActionAttack
{
[HarmonyPostfix]
[HarmonyPatch("ChooseAttackOption")]
private static void Post_ChooseAttackOption(PlayerBotActionAttack __instance, ref bool __result)
{
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Invalid comparison between Unknown and I4
if (!__result)
{
return;
}
BotRecorder component = ((Component)((PlayerBotActionBase)__instance).m_agent).gameObject.GetComponent<BotRecorder>();
if (!((Object)(object)component != (Object)null))
{
return;
}
ItemEquippable bestItemToUse;
if (PlayerBotManagerExtended.LoudStateIsEarlyToMelee)
{
if (PlayerBotManagerExtended.TryGetBestMeleeWeapon(PlayerBackpackManager.GetBackpack(((PlayerBotActionBase)__instance).m_agent.Owner), out var weapon))
{
__instance.m_currentAttackOption.Means = (AttackMeansEnum)1;
__instance.m_currentAttackOption.Prio = 100000f;
__instance.m_currentAttackOption.ItemToUse = (ItemEquippable)(object)weapon;
__instance.m_currentAttackOption.Stance = (StanceEnum)2;
}
}
else if (component.Brain.HasAmmo() && component.Brain.ForceBulletsOnly && PlayerBotManagerExtended.TryToGetBestWeapon(((PlayerBotActionBase)__instance).m_agent, out bestItemToUse) && (int)__instance.m_currentAttackOption.Means != 4)
{
__instance.m_currentAttackOption.Means = (AttackMeansEnum)4;
__instance.m_currentAttackOption.Prio = 100000f;
__instance.m_currentAttackOption.ItemToUse = bestItemToUse;
__instance.m_currentAttackOption.Stance = (StanceEnum)1;
}
}
}
[HarmonyPatch(typeof(PlayerBotActionBioscanProximity))]
internal class Patch_PlayerBotActionBioscanProximity
{
[HarmonyPostfix]
[HarmonyPatch("VerifyScanner")]
private static void Post_VerifyScanner(PlayerBotActionBioscanProximity __instance, ref bool __result)
{
if ((Object)(object)__instance.m_desc.Bioscan != (Object)null && __instance.m_desc.Bioscan.IsExitPuzzle)
{
__result = true;
}
}
}
[HarmonyPatch(typeof(PlayerBotActionCarryExpeditionItem))]
internal class Patch_PlayerBotActionCarryExpeditionItem
{
[HarmonyPostfix]
[HarmonyPatch("UpdateStateIdle")]
private static void Post_UpdateStateIdle(PlayerBotActionCarryExpeditionItem __instance)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
BotRecorder component = ((Component)((PlayerBotActionBase)__instance).m_agent).gameObject.GetComponent<BotRecorder>();
if ((Object)(object)component != (Object)null && !component.IsDangerousToCollectExpeditionItem() && (!component.m_firstExpeditionItemTimer || component.m_abortExpeditionItemTimer + 3f < Time.time) && !__instance.m_isCarrying && !PlayerBotManagerExtended.IsBotCurrentlyBusyWithAction(((PlayerBotActionBase)__instance).m_bot))
{
__instance.m_collectAction.TargetPosition = ((Component)__instance.m_desc.TargetItem).transform.position;
if (((PlayerBotActionBase)__instance).m_bot.RequestAction((Descriptor)(object)__instance.m_collectAction))
{
__instance.SetState((State)1);
}
}
}
}
[HarmonyPatch(typeof(PlayerBotActionUseBioscan))]
internal class Patch_PlayerBotActionUseBioscan
{
[HarmonyPostfix]
[HarmonyPatch("VerifyScanner")]
private static void Post_VerifyScanner(PlayerBotActionUseBioscan __instance, ref bool __result)
{
if ((Object)(object)__instance.m_desc.Bioscan != (Object)null && __instance.m_desc.Bioscan.IsExitPuzzle)
{
__result = true;
}
}
}
[HarmonyPatch(typeof(PlayerBotActionUseFirearm))]
internal class Patch_PlayerBotActionUseFireArm
{
[HarmonyPrefix]
[HarmonyPatch("TestFriendlyFire")]
private static bool Pre_TestFriendlyFire(PlayerBotActionUseFirearm __instance, ref bool __result)
{
__result = PlayerBotManagerExtended.TryToHitEnemy(((PlayerBotActionBase)__instance).m_agent, out var _, out var _);
return false;
}
}
[HarmonyPatch(typeof(RootPlayerBotAction))]
internal class Patch_RootPlayerBotAction
{
[HarmonyPrefix]
[HarmonyPatch("UpdateActionReviveTeammate")]
private static bool Pre_UpdateActionReviveTeammate(RootPlayerBotAction __instance)
{
BotRecorder component = ((Component)((PlayerBotActionBase)__instance).m_agent).gameObject.GetComponent<BotRecorder>();
if ((Object)(object)component != (Object)null)
{
return !component.Brain.ReviveRestricted;
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch("UpdateActionShareResoursePack")]
private static bool Pre_UpdateActionShareResoursePack(RootPlayerBotAction __instance)
{
BotRecorder component = ((Component)((PlayerBotActionBase)__instance).m_agent).gameObject.GetComponent<BotRecorder>();
if ((Object)(object)component != (Object)null)
{
return !component.IsInDangerousSituation();
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch("UpdateActionCollectItem")]
private static bool Pre_UpdateActionCollectItem(RootPlayerBotAction __instance, ref Descriptor bestAction)
{
//IL_026a: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: 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_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
if (((Descriptor)__instance.m_collectItemAction).IsTerminated())
{
((Descriptor)__instance.m_collectItemAction).Prio = RootPlayerBotAction.m_prioSettings.CollectItem;
if (RootPlayerBotAction.CompareActionPrios((Descriptor)(object)__instance.m_collectItemAction, bestAction) && !PlayerBackpackManager.GetBackpack(((PlayerBotActionBase)__instance).m_agent.Owner).HasBackpackItem((InventorySlot)8) && !((PlayerBotActionBase)__instance).m_bot.IsActionForbidden((Descriptor)(object)__instance.m_collectItemAction))
{
ItemPriorityData itemPriorityData = new ItemPriorityData(((PlayerBotActionBase)__instance).m_agent);
AIG_CourseNode courseNode = ((Agent)((PlayerBotActionBase)__instance).m_agent).CourseNode;
for (int i = 0; i < courseNode.MetaData.StorageContainers.Count; i++)
{
LG_ResourceContainer_Storage val = courseNode.MetaData.StorageContainers[i];
LG_WeakResourceContainer component = ((Component)val).gameObject.GetComponent<LG_WeakResourceContainer>();
if (!((Object)(object)component != (Object)null) || !component.ISOpen)
{
continue;
}
((AIReservation)RootPlayerBotAction.s_tempObjReservation).CharacterID = ((PlayerBotActionBase)__instance).m_agent.CharacterID;
RootPlayerBotAction.s_tempObjReservation.Object = ((Component)val).gameObject;
if (PlayerManager.Current.IsObjectReserved(RootPlayerBotAction.s_tempObjReservation) || ((PlayerBotActionBase)__instance).IsAnyHumanPlayerNear(((Component)val).transform.position, 7f))
{
continue;
}
Vector3 val2 = ((Component)val).transform.position - ((Component)val).transform.up * RootPlayerBotAction.s_collectItemStandDistance;
if (!((PlayerBotActionBase)__instance).SnapPositionToNav(val2, ref val2))
{
continue;
}
((AIReservation)RootPlayerBotAction.s_tempPosReservation).CharacterID = ((PlayerBotActionBase)__instance).m_agent.CharacterID;
RootPlayerBotAction.s_tempPosReservation.Position = val2;
if (PlayerManager.Current.IsPositionReserved(RootPlayerBotAction.s_tempPosReservation))
{
continue;
}
float prio = ((Descriptor)__instance.m_collectItemAction).Prio;
if (((PlayerBotActionBase)__instance).m_bot.ApplyRestrictionsToRootPosition(ref val2, ref prio) || !PlayerBotManagerExtended.GetItemsFromStorageContainer(val, out var storageItems))
{
continue;
}
for (int j = 0; j < storageItems.Count; j++)
{
Item val3 = storageItems[j];
if (val3.ItemDataBlock != null && !ItemPriorityData.BlockedItems.Contains(((GameDataBlockBase<ItemDataBlock>)(object)val3.ItemDataBlock).persistentID))
{
itemPriorityData.UpcomingItemGrabStatus = new ItemPriorityData.ItemGrabStats
{
Item = val3,
Position = val2,
Container = val
};
itemPriorityData.DeterminePriority();
}
}
}
if (itemPriorityData.CurrentItemGrabStatus != null)
{
__instance.m_collectItemAction.TargetItem = itemPriorityData.CurrentItemGrabStatus.Item;
__instance.m_collectItemAction.TargetContainer = itemPriorityData.CurrentItemGrabStatus.Container;
__instance.m_collectItemAction.TargetPosition = itemPriorityData.CurrentItemGrabStatus.Position;
__instance.m_collectItemAction.Haste = ((DramaManager.GoToCombat || DramaManager.GoToEncounter) ? 2f : 0.5f);
bestAction = (Descriptor)(object)__instance.m_collectItemAction;
}
}
}
return false;
}
}
[HarmonyPatch(typeof(StartMainGame))]
internal class Patch_StartMainGame
{
[HarmonyPostfix]
[HarmonyPatch("Start")]
private static void PostStart()
{
BetterBots.OnStartGame();
}
}
[HarmonyPatch(typeof(Weapon))]
internal class Patch_Weapon
{
[HarmonyPrefix]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
private static void Pre_CastWeaponRay(Transform alignTransform, ref WeaponHitData weaponRayData, ref Vector3 originPos, ref int altRayCastMask)
{
if (SNet.IsMaster && weaponRayData != null && (Object)(object)weaponRayData.owner != (Object)null && (Object)(object)weaponRayData.owner.Owner != (Object)null && weaponRayData.owner.Owner.IsBot && altRayCastMask == -1)
{
altRayCastMask = PlayerBotManagerExtended.MASK_BULLET_RAY_BOTS;
}
}
}
}
namespace BetterBots.Managers
{
public static class BotRecorderManager
{
private static List<BotRecorder> s_recorders = new List<BotRecorder>();
private static int s_lastGuiSlotIndex = -1;
private const float m_recty = 300f;
public const float m_height = 2000f;
private static Rect[] s_guiSlots = (Rect[])(object)new Rect[4]
{
new Rect(400f, 300f, 500f, 2000f),
new Rect(700f, 300f, 500f, 2000f),
new Rect(1000f, 300f, 500f, 2000f),
new Rect(1200f, 300f, 500f, 2000f)
};
public const bool m_guiManagerEnabled = false;
public static void RegisterBotRecorder(BotRecorder recorder)
{
}
private static void AssignSlotIndex(BotRecorder recorder)
{
//IL_0022: 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)
s_lastGuiSlotIndex++;
recorder.m_guiSlotIndex = s_lastGuiSlotIndex;
recorder.m_guiSlot = s_guiSlots[s_lastGuiSlotIndex];
recorder.m_hasGuiSlot = true;
}
public static void DeRegisterRecorder(BotRecorder recorderDestroyed)
{
}
}
public static class ConfigurationPluginManager
{
private static bool Inited;
private static ConfigFile ConfigurationFile;
public static bool BetterBotsAimBot;
public static void Initialized()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
if (!Inited)
{
Inited = true;
ConfigurationFile = new ConfigFile(Path.Combine(Paths.ConfigPath, "BetterBots.cfg"), true);
ConfigDefinition val = new ConfigDefinition("Improved Aim", "Enabled");
ConfigDescription val2 = new ConfigDescription("Improves the bots' accuracy by 100%", (AcceptableValueBase)null, (object[])null);
ConfigurationFile.Bind<bool>(val, false, val2);
ConfigEntry<bool> val3 = default(ConfigEntry<bool>);
if (ConfigurationFile.TryGetEntry<bool>(val, ref val3))
{
BetterBotsAimBot = val3.Value;
}
ConfigurationFile.Save();
}
}
}
public static class PlayerBotManagerExtended
{
public class AimSpot
{
public Dam_EnemyDamageLimb DamLimb;
public float Prio;
public static readonly float HEAD_LIMB_PRIO = 2f;
public static readonly float WEAK_LIMB_PRIO = 3f;
public static readonly float DEFAULT_LIMB_PRIO = 1f;
}
public class AttackEnemy
{
public bool Awake;
public EnemyAgent Enemy;
public float Prio;
public AttackEnemy(EnemyAgent enemyAgent)
{
Enemy = enemyAgent;
}
private bool IsAwake()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Invalid comparison between Unknown and I4
bool flag = default(bool);
bool flag2 = default(bool);
Enemy.AI.IsHibernating(ref flag, ref flag2);
if ((int)((AgentAI)Enemy.AI).Mode == 1 || flag2)
{
return true;
}
return false;
}
public bool IsAttackable()
{
//IL_0052: 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 (IsAwake())
{
return true;
}
if (((Agent)Enemy).CourseNode == null)
{
return false;
}
List<EnemyAgent> reachableEnemiesInNodes = AIG_CourseGraph.GetReachableEnemiesInNodes(((Agent)Enemy).CourseNode, 2);
if (reachableEnemiesInNodes != null)
{
Enumerator<EnemyAgent> enumerator = reachableEnemiesInNodes.GetEnumerator();
while (enumerator.MoveNext())
{
EnemyAgent current = enumerator.Current;
if ((Object)(object)current != (Object)(object)Enemy)
{
float num = Vector3.Distance(Enemy.ListenerPosition, current.ListenerPosition);
float num2 = current.EnemyDetectionData.movementDetectionDistance * 0.1f;
if (current.EnemyDetectionData.movementDetectionDistance + num2 > num)
{
return false;
}
}
}
}
return true;
}
}
private static float m_loudStateEnter;
private static bool m_hasLoudStateEnter;
public static int MASK_BULLET_RAY_BOTS;
private static List<BotRecorder> m_botRecorders;
public static bool HasLoudStateEnter
{
get
{
return m_hasLoudStateEnter;
}
set
{
if (m_hasLoudStateEnter != value)
{
m_hasLoudStateEnter = value;
if (m_hasLoudStateEnter)
{
m_loudStateEnter = Time.time;
}
}
}
}
public static bool LoudStateIsEarlyToMelee
{
get
{
if (m_hasLoudStateEnter)
{
return m_loudStateEnter + 3f > Time.time;
}
return false;
}
}
public static void Awake()
{
m_botRecorders = new List<BotRecorder>();
MASK_BULLET_RAY_BOTS = LayerManager.Current.GetMask(new string[6] { "Default", "Default_NoGraph", "Default_BlockGraph", "EnemyDamagable", "ProjectileBlocker", "Dynamic" });
BBLog.Message("PlayerBotManagerExtended, Awake");
}
public static bool IsBotCurrentlyBusyWithAction(PlayerAIBot bot)
{
Descriptor targetDesc;
bool flag = bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc);
Descriptor targetDesc2;
bool flag2 = bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc2);
Descriptor targetDesc3;
bool flag3 = bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc3);
Descriptor targetDesc4;
bool flag4 = bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc4);
Descriptor targetDesc5;
bool flag5 = bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc5);
Descriptor targetDesc6;
bool flag6 = bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc6);
Descriptor targetDesc7;
Descriptor targetDesc8;
return bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc7) || bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out targetDesc8) || flag || flag2 || flag3 || flag4 || flag5 || flag6;
}
public static void Start()
{
}
public static void Update()
{
}
public static float AddBonusMulitplier(float originalValue, float multiplier)
{
float num = originalValue * multiplier;
return originalValue += num;
}
public static float SubtractBonusMulitplier(float originalValue, float multiplier)
{
float num = originalValue * multiplier;
return originalValue -= num;
}
private static void UpdateForcedUnlockObjective()
{
//IL_003e: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
SyncedNavMarkerWrapper[] array = Il2CppArrayBase<SyncedNavMarkerWrapper>.op_Implicit((Il2CppArrayBase<SyncedNavMarkerWrapper>)(object)GuiManager.Current.m_playerPings);
for (int i = 0; i < array.Length; i++)
{
if (!array[i].NavMarkerIsVisible() || IsPlayerSlotIndexBot(array[i].m_playerIndex))
{
continue;
}
Collider[] array2 = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(((Component)array[i]).transform.position, 10f, LayerManager.MASK_PING_TARGET));
if (array2.Length == 0)
{
continue;
}
for (int j = 0; j < array2.Length; j++)
{
LG_WeakResourceContainer componentInParent = ((Component)array2[i]).gameObject.GetComponentInParent<LG_WeakResourceContainer>();
if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.m_weakLock != (Object)null && (int)componentInParent.m_weakLock.m_lockType != 0 && !IsObjectReservedForUnlockAction(((Component)componentInParent).gameObject) && TryToGetClosestPlayerBotToStorage(((Component)componentInParent).gameObject, componentInParent.m_weakLock.m_lockType, out var bestBotRecorder))
{
bestBotRecorder.ForceUnlockAction(componentInParent, componentInParent.m_weakLock.m_lockType);
}
}
}
}
public static bool IsObjectReservedForUnlockAction(GameObject gameObject)
{
for (int i = 0; i < m_botRecorders.Count; i++)
{
BotRecorder botRecorder = m_botRecorders[i];
if (botRecorder.HasRootAction && !((Descriptor)botRecorder.RootAction.m_unlockAction).IsTerminated() && (Object)(object)botRecorder.RootAction.m_unlockAction.TargetGO == (Object)(object)gameObject)
{
return true;
}
}
return false;
}
private static bool TryToGetClosestPlayerBotToStorage(GameObject storage, eWeakLockType lockType, out BotRecorder bestBotRecorder)
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Invalid comparison between Unknown and I4
//IL_0052: 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)
bestBotRecorder = null;
float num = 0f;
for (int i = 0; i < m_botRecorders.Count; i++)
{
BotRecorder botRecorder = m_botRecorders[i];
if (botRecorder.HasRootAction && ((Agent)botRecorder.Agent).Alive && ((Descriptor)botRecorder.RootAction.m_unlockAction).IsTerminated() && ((int)lockType == 1 || botRecorder.HasLockMelters()))
{
float num2 = Vector3.Distance(((Agent)botRecorder.Agent).Position, storage.transform.position);
if ((Object)(object)bestBotRecorder == (Object)null || num > num2)
{
bestBotRecorder = botRecorder;
num = num2;
}
}
}
return (Object)(object)bestBotRecorder != (Object)null;
}
public static void FixedUpdate()
{
}
public static void LateUpdate()
{
}
public static bool IsPlayerSlotIndexBot(int playerSlotIndex)
{
for (int i = 0; i < PlayerManager.PlayerAgentsInLevel.Count; i++)
{
PlayerAgent val = PlayerManager.PlayerAgentsInLevel[i];
if ((Object)(object)val != (Object)null && val.PlayerSlotIndex == playerSlotIndex)
{
return val.Owner.IsBot;
}
}
return false;
}
public static void RegisterBotRecoder(BotRecorder botRecorder)
{
if (!m_botRecorders.Contains(botRecorder))
{
m_botRecorders.Add(botRecorder);
}
}
public static void DeRegisterBotRecorder(BotRecorder botRecorder)
{
if (m_botRecorders.Contains(botRecorder))
{
m_botRecorders.Remove(botRecorder);
}
}
public static float GetAmmoRel(PlayerBackpack backPack, AmmoType ammoType)
{
//IL_0006: 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_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Invalid comparison between Unknown and I4
float ammoInPack = backPack.AmmoStorage.GetAmmoInPack(ammoType);
if ((int)ammoType != 0)
{
if ((int)ammoType == 1)
{
return backPack.AmmoStorage.GetClipAmmoFromSlot((InventorySlot)2) + ammoInPack;
}
return 0f;
}
return backPack.AmmoStorage.GetClipAmmoFromSlot((InventorySlot)1) + ammoInPack;
}
public static bool TryGetBulletWeapon(PlayerBackpack playerBackpack, InventorySlot slot, out BulletWeaponSynced weapon)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
weapon = null;
BackpackItem val = default(BackpackItem);
if (playerBackpack.TryGetBackpackItem(slot, ref val) && (Object)(object)val.Instance != (Object)null)
{
ItemEquippable val2 = ((Il2CppObjectBase)val.Instance).TryCast<ItemEquippable>();
if ((Object)(object)val2 != (Object)null && val2.IsWeapon && (Object)(object)val2.WeaponComp != (Object)null)
{
weapon = ((Il2CppObjectBase)val2.WeaponComp).TryCast<BulletWeaponSynced>();
return (Object)(object)weapon != (Object)null;
}
}
return false;
}
public static bool TryGetBestMeleeWeapon(PlayerBackpack playerBackpack, out MeleeWeaponThirdPerson weapon)
{
weapon = null;
BackpackItem val = default(BackpackItem);
if (playerBackpack.TryGetBackpackItem((InventorySlot)10, ref val) && (Object)(object)val.Instance != (Object)null)
{
ItemEquippable val2 = ((Il2CppObjectBase)val.Instance).TryCast<ItemEquippable>();
if ((Object)(object)val2 != (Object)null)
{
weapon = ((Il2CppObjectBase)val2).TryCast<MeleeWeaponThirdPerson>();
return (Object)(object)weapon != (Object)null;
}
}
return false;
}
public static bool TryToGetBestWeapon(PlayerAgent playerAgent, out ItemEquippable bestItemToUse)
{
bestItemToUse = null;
PlayerBackpack playerBackpack = default(PlayerBackpack);
PlayerBackpackManager.TryGetBackpack(playerAgent.Owner, ref playerBackpack);
if (playerBackpack == null)
{
return false;
}
float highestClipsRel = 0f;
float highestBulletInPackRel = 0f;
BulletWeaponSynced weapon;
bool flag = TryGetBulletWeapon(playerBackpack, (InventorySlot)1, out weapon);
BulletWeaponSynced weapon2;
bool flag2 = TryGetBulletWeapon(playerBackpack, (InventorySlot)2, out weapon2);
if (flag2)
{
DetermineBestWeapon(weapon2, ignoreClip: false, ref bestItemToUse);
}
if (flag)
{
DetermineBestWeapon(weapon, ignoreClip: false, ref bestItemToUse);
}
if ((Object)(object)bestItemToUse == (Object)null)
{
if (flag2)
{
DetermineBestWeapon(weapon2, ignoreClip: true, ref bestItemToUse);
}
if (flag)
{
DetermineBestWeapon(weapon, ignoreClip: true, ref bestItemToUse);
}
}
return (Object)(object)bestItemToUse != (Object)null;
void DetermineBestWeapon(BulletWeaponSynced bulletWeapon, bool ignoreClip, ref ItemEquippable bestitemEquippable)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
float currentClipRel = ((ItemEquippable)bulletWeapon).GetCurrentClipRel();
float bulletsRelInPack = playerBackpack.AmmoStorage.GetBulletsRelInPack(((ItemEquippable)bulletWeapon).AmmoType);
if (ignoreClip)
{
if (bulletsRelInPack > 0f && bulletsRelInPack > highestBulletInPackRel)
{
bestitemEquippable = (ItemEquippable)(object)bulletWeapon;
highestBulletInPackRel = bulletsRelInPack;
}
}
else if (currentClipRel > 0f && currentClipRel > highestClipsRel)
{
bestitemEquippable = (ItemEquippable)(object)bulletWeapon;
highestClipsRel = currentClipRel;
}
}
}
public static bool TryToGetLimb(EnemyAgent enemy, bool includeHeadLimb, out AimSpot bestTargetAimSpot)
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: 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_006f: Invalid comparison between Unknown and I4
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: 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_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: 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)
//IL_00ad: Invalid comparison between Unknown and I4
bestTargetAimSpot = null;
if ((Object)(object)enemy.ModelRef == (Object)null)
{
return false;
}
if (enemy.Damage.DamageLimbs != null && ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)enemy.Damage.DamageLimbs).Count > 0)
{
Vector3 eyePosition = ((Agent)enemy).EyePosition;
float num = 0f;
for (int i = 0; i < ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)enemy.Damage.DamageLimbs).Count; i++)
{
Dam_EnemyDamageLimb val = ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)enemy.Damage.DamageLimbs)[i];
if ((Object)(object)val != (Object)null && (int)val.m_type != 2 && !val.IsDestroyed)
{
Vector3 position = ((Component)val).transform.position;
Vector3 val2 = eyePosition - position;
float magnitude = ((Vector3)(ref val2)).magnitude;
AimSpot aimSpot = new AimSpot
{
DamLimb = val,
Prio = (((int)val.m_type == 1) ? AimSpot.WEAK_LIMB_PRIO : AimSpot.DEFAULT_LIMB_PRIO)
};
if (bestTargetAimSpot == null || (num > magnitude && aimSpot.Prio > bestTargetAimSpot.Prio))
{
num = magnitude;
bestTargetAimSpot = aimSpot;
}
}
}
}
if (includeHeadLimb && (Object)(object)enemy.m_headLimb != (Object)null && !enemy.m_headLimb.IsDestroyed)
{
AimSpot aimSpot2 = new AimSpot
{
DamLimb = enemy.m_headLimb,
Prio = AimSpot.HEAD_LIMB_PRIO
};
if (bestTargetAimSpot == null || aimSpot2.Prio > bestTargetAimSpot.Prio)
{
bestTargetAimSpot = aimSpot2;
}
}
return bestTargetAimSpot != null;
}
public static bool TryToHitEnemy(PlayerAgent playerAgent, out Vector3 hitDir, out RaycastHit raycastHit)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: 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)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: 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)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: 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)
hitDir = Vector3.zero;
raycastHit = default(RaycastHit);
if (playerAgent.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out Descriptor targetDesc) && (Object)(object)targetDesc.TargetAgent != (Object)null)
{
EnemyAgent val = ((Il2CppObjectBase)targetDesc.TargetAgent).TryCast<EnemyAgent>();
if ((Object)(object)val != (Object)null && TryToGetLimb(val, includeHeadLimb: true, out var bestTargetAimSpot) && (Object)(object)playerAgent.Inventory != (Object)null && (Object)(object)playerAgent.Inventory.WieldedItem != (Object)null)
{
Collider component = ((Component)bestTargetAimSpot.DamLimb).GetComponent<Collider>();
if ((Object)(object)component != (Object)null)
{
Transform muzzleAlign = playerAgent.Inventory.WieldedItem.MuzzleAlign;
Bounds bounds = component.bounds;
hitDir = ((Bounds)(ref bounds)).center - muzzleAlign.position;
if (Physics.Raycast(muzzleAlign.position, hitDir, ref raycastHit, 100000f, LayerManager.MASK_BULLETWEAPON_RAY, (QueryTriggerInteraction)1))
{
GameObject gameObject = ((Component)((RaycastHit)(ref raycastHit)).collider).gameObject;
if ((Object)(object)gameObject.GetComponentInParent<EnemyAgent>() != (Object)null)
{
return (Object)(object)gameObject.GetComponentInParent<PlayerAgent>() == (Object)null;
}
}
}
}
}
return false;
}
public static bool TryGetActionDescriptor<PAD>(this PlayerAgent playerAgent, bool queued, bool active, out PAD targetDesc) where PAD : Descriptor
{
targetDesc = default(PAD);
PlayerAIBot component = ((Component)playerAgent).gameObject.GetComponent<PlayerAIBot>();
if ((Object)(object)component != (Object)null)
{
return component.TryGetActionDescriptor<PAD>(queued, active, out targetDesc);
}
return false;
}
public static bool TryGetActionDescriptor<PAD>(this PlayerAIBot bot, bool queued, bool active, out PAD targetDesc) where PAD : Descriptor
{
targetDesc = default(PAD);
if ((Object)(object)bot != (Object)null)
{
if (queued)
{
for (int i = 0; i < bot.m_queuedActions.Count; i++)
{
Descriptor val = bot.m_queuedActions[i];
if (val != null)
{
PAD val2 = ((Il2CppObjectBase)val).TryCast<PAD>();
if (val2 != null)
{
targetDesc = val2;
return true;
}
}
}
}
if (active)
{
for (int j = 0; j < bot.m_actions.Count; j++)
{
PlayerBotActionBase val3 = bot.m_actions[j];
if (val3 != null && val3.DescBase != null)
{
PAD val4 = ((Il2CppObjectBase)val3.DescBase).TryCast<PAD>();
if (val4 != null)
{
targetDesc = val4;
return true;
}
}
}
}
}
return false;
}
public static bool GetItemsFromStorageContainer(LG_ResourceContainer_Storage storage, out List<Item> storageItems)
{
//IL_0026: 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_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
storageItems = new List<Item>();
Il2CppArrayBase<BoxCollider> componentsInChildren = ((Component)storage).GetComponentsInChildren<BoxCollider>();
if (componentsInChildren != null && componentsInChildren.Count > 0)
{
Collider[] array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(((Component)storage).transform.position, 2f, LayerManager.MASK_APPLY_CARRY_ITEM, (QueryTriggerInteraction)1));
if (array.Length != 0)
{
for (int i = 0; i < array.Length; i++)
{
Item componentInParent = ((Component)array[i]).GetComponentInParent<Item>();
if (!((Object)(object)componentInParent != (Object)null))
{
continue;
}
for (int j = 0; j < componentsInChildren.Count; j++)
{
Bounds bounds = ((Collider)componentsInChildren[j]).bounds;
if (((Bounds)(ref bounds)).Contains(((Component)componentInParent).transform.position))
{
storageItems.Add(componentInParent);
break;
}
}
}
}
}
return storageItems.Count > 0;
}
public static int PriorityBasedOnItem(uint itemID)
{
return itemID switch
{
101u => 10,
127u => 9,
102u => 8,
132u => 7,
_ => 0,
};
}
public static float GetTotalAmmoRel()
{
int num = 0;
float num2 = 0f;
BackpackItem val = default(BackpackItem);
BackpackItem val2 = default(BackpackItem);
for (int i = 0; i < PlayerManager.PlayerAgentsInLevel.Count; i++)
{
PlayerBackpack backpack = PlayerBackpackManager.GetBackpack(PlayerManager.PlayerAgentsInLevel[i].Owner);
if (backpack.TryGetBackpackItem((InventorySlot)1, ref val))
{
num++;
num2 += backpack.AmmoStorage.StandardAmmo.RelInPack;
}
if (backpack.TryGetBackpackItem((InventorySlot)2, ref val2))
{
num++;
num2 += backpack.AmmoStorage.SpecialAmmo.RelInPack;
}
}
return num2 / (float)num;
}
public static float GetOverallHealth()
{
float num = 0f;
float num2 = 0f;
List<PlayerAgent> playerAgentsInLevel = PlayerManager.PlayerAgentsInLevel;
if (playerAgentsInLevel.Count > 0)
{
for (int i = 0; i < playerAgentsInLevel.Count; i++)
{
PlayerAgent val = playerAgentsInLevel[i];
if ((Object)(object)val != (Object)null)
{
num2 += ((Dam_SyncedDamageBase)val.Damage).GetHealthRel();
num += 1f;
}
}
}
return num2 / num;
}
public static bool TryToGetClosestPlayerAgentToPlayer(PlayerAgent sourcePlayer, out PlayerAgent otherPlayer)
{
//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)
otherPlayer = null;
List<PlayerAgent> playerAgentsInLevel = PlayerManager.PlayerAgentsInLevel;
bool flag = false;
float num = 0f;
for (int i = 0; i < playerAgentsInLevel.Count; i++)
{
PlayerAgent val = playerAgentsInLevel[i];
if (((Object)val).GetInstanceID() != ((Object)sourcePlayer).GetInstanceID() && !val.Owner.IsBot && ((Agent)val).Alive)
{
float num2 = Vector3.Distance(((Agent)val).Position, ((Agent)sourcePlayer).Position);
if (!flag || num2 < num)
{
otherPlayer = val;
num = num2;
flag = true;
}
}
}
return flag;
}
public static bool HasEndlessWave()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
if (Mastermind.Current.m_events == null)
{
return false;
}
Enumerator<MastermindEvent> enumerator = Mastermind.Current.m_events.GetEnumerator();
while (enumerator.MoveNext())
{
MastermindEvent current = enumerator.Current;
if ((int)current.EventType == 1)
{
SurvivalWave val = ((Il2CppObjectBase)current).TryCast<SurvivalWave>();
if ((Object)(object)val != (Object)null && val.m_settings.m_populationPointsTotal < 0f)
{
return true;
}
}
}
return false;
}
}
}
namespace BetterBots.Data
{
public class PlayerBotForcedUnlockAction
{
public PlayerAIBot Bot;
public PlayerBotForcedUnlockAction(PlayerAIBot bot)
{
Bot = bot;
}
public void ForceUnlockAction(LG_WeakResourceContainer storage, eWeakLockType lockType, Descriptor descriptor)
{
//IL_0018: 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_0037: Invalid comparison between Unknown and I4
descriptor.TargetGO = ((Component)storage).gameObject;
descriptor.TargetPosition = ((Component)storage).gameObject.transform.position;
descriptor.TargetType = (TargetTypeEnum)1;
((Descriptor)descriptor).Prio = 500f;
descriptor.Method = (MethodEnum)(((int)lockType != 2) ? 1 : 4);
descriptor.Lock = storage.m_weakLock;
Bot.StartAction((Descriptor)(object)descriptor);
}
}
public class ItemPriorityData
{
public class ItemGrabStats
{
public LG_ResourceContainer_Storage Container;
public Item Item;
public Vector3 Position;
}
public PlayerAgent Player;
public static List<uint> BlockedItems = new List<uint> { 114u, 130u, 167u, 174u, 140u, 142u, 30u };
public ItemGrabStats UpcomingItemGrabStatus;
public ItemGrabStats CurrentItemGrabStatus;
public float BestPriority;
public ItemPriorityData(PlayerAgent player)
{
Player = player;
}
private bool IsBackPackItemPrefferable()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
return PlayerBackpackManager.GetBackpack(Player.Owner).HasBackpackItem(UpcomingItemGrabStatus.Item.ItemDataBlock.inventorySlot);
}
public void DeterminePriority()
{
//IL_0021: 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)
if (UpcomingItemGrabStatus != null && CanGrabItem() && !IsBackPackItemPrefferable())
{
float num = Vector3.Distance(((Agent)Player).Position, UpcomingItemGrabStatus.Position);
switch (((GameDataBlockBase<ItemDataBlock>)(object)UpcomingItemGrabStatus.Item.ItemDataBlock).persistentID)
{
case 101u:
num /= Mathf.Lerp(10f, 4f, PlayerBotManagerExtended.GetTotalAmmoRel());
break;
case 102u:
num /= Mathf.Lerp(5f, 2f, PlayerBotManagerExtended.GetOverallHealth());
break;
}
if (CurrentItemGrabStatus == null || BestPriority > num)
{
BestPriority = num;
CurrentItemGrabStatus = UpcomingItemGrabStatus;
}
}
}
private bool CanGrabItem()
{
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: 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_0063: Invalid comparison between Unknown and I4
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Invalid comparison between Unknown and I4
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: 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)
if ((Object)(object)UpcomingItemGrabStatus.Item.PickupInteraction == (Object)null)
{
return false;
}
Interact_Base pickupInteraction = UpcomingItemGrabStatus.Item.PickupInteraction;
if (!pickupInteraction.IsActive || pickupInteraction.ManualTriggeringOnly || !pickupInteraction.PlayerCanInteract(Player))
{
return false;
}
InventorySlot inventorySlot = UpcomingItemGrabStatus.Item.ItemDataBlock.inventorySlot;
if ((int)inventorySlot != 5 && (int)inventorySlot != 4)
{
return false;
}
float num = RootPlayerBotAction.s_collectItemSearchDistance;
if (PlayerBotManagerExtended.HasEndlessWave() || ((GameDataBlockBase<ItemDataBlock>)(object)UpcomingItemGrabStatus.Item.ItemDataBlock).persistentID == 101)
{
num *= 10f;
}
Vector3 val = ((Component)UpcomingItemGrabStatus.Item).transform.position - ((Agent)Player).Position;
return ((Vector3)(ref val)).magnitude < num;
}
}
public class PB_Base
{
protected PlayerBotBrain m_brain;
public PB_Base(PlayerBotBrain brain)
{
m_brain = brain;
}
public virtual void UpdateBrain()
{
}
}
public class PB_Damage : PB_Base
{
private bool m_firstCheck;
private float m_lastHealthRatio;
private float m_damageTakenTime;
private bool m_firstDamageTaken;
public bool IsTakingDamage => HasTakenDamageFromTimePassed(3f);
public PB_Damage(PlayerBotBrain brain)
: base(brain)
{
}
public override void UpdateBrain()
{
float healthRel = ((Dam_SyncedDamageBase)m_brain.Agent.Damage).GetHealthRel();
if (!m_firstCheck)
{
m_firstCheck = true;
m_lastHealthRatio = healthRel;
}
else if (healthRel != m_lastHealthRatio)
{
if (healthRel < m_lastHealthRatio)
{
m_damageTakenTime = Time.time;
m_firstDamageTaken = true;
}
m_lastHealthRatio = healthRel;
}
}
public bool HasTakenDamageFromTimePassed(float timePassed)
{
if (m_firstDamageTaken)
{
return m_damageTakenTime + timePassed > Time.time;
}
return false;
}
}
public class PB_Friendlies : PB_Base
{
public struct FriendlyStatus
{
public int m_tm_CanSee;
public int m_tm_CanSee_Close;
public float m_rev_confidence;
}
private static class Settings
{
public static readonly float Rev_Con_MaxDistance = 15f;
public static readonly float Rev_Con_MixDistance = 5f;
public static readonly float Rev_Close_Distance_Friendly = 5f;
}
private FriendlyStatus m_friendlyStatus;
public FriendlyStatus CurrentFriendlyStatus => m_friendlyStatus;
public PB_Friendlies(PlayerBotBrain brain)
: base(brain)
{
}
public override void UpdateBrain()
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
if (((Agent)m_brain.Agent).CourseNode == null)
{
m_friendlyStatus = default(FriendlyStatus);
return;
}
FriendlyStatus friendlyStatus = default(FriendlyStatus);
List<PlayerAgent> playerAgentsInLevel = PlayerManager.PlayerAgentsInLevel;
for (int i = 0; i < playerAgentsInLevel.Count; i++)
{
PlayerAgent val = playerAgentsInLevel[i];
if (val.CharacterID == m_brain.Agent.CharacterID || !((Agent)val).Alive)
{
continue;
}
bool num = m_brain.Agent.CanSeeObject(m_brain.EyePosition, ((Component)val).gameObject);
float num2 = Vector3.Distance(((Agent)m_brain.Agent).Position, ((Agent)val).Position);
if (num)
{
friendlyStatus.m_tm_CanSee++;
if (num2 < Settings.Rev_Close_Distance_Friendly)
{
friendlyStatus.m_tm_CanSee_Close++;
}
}
}
m_friendlyStatus = friendlyStatus;
}
}
public class PB_Revive : PB_Base
{
public static class Settings
{
public static int s_attackers_Visible_Restrict_Revive = 5;
public static int s_attackers_Close_And_Visible_Restrict_Revive = 2;
public static int s_attackers_OneShot_Close_And_Visible_Restrict_Revive = 1;
public static float s_reviveConfidenceProgressUninterrupted = 0.7f;
public static float s_takingDamageDecay = 3f;
}
public bool ReviveIsDangerous
{
get
{
if (m_brain.m_friendliesBrain.CurrentFriendlyStatus.m_tm_CanSee_Close > 2)
{
return false;
}
if (m_brain.m_enemyBrain.EnemyDetection.m_amountOfSeenEnemiesClose >= Settings.s_attackers_Close_And_Visible_Restrict_Revive)
{
return true;
}
if (m_brain.m_enemyBrain.EnemyDetection.m_amountOfSeenOneShotEnemiesClose >= Settings.s_attackers_OneShot_Close_And_Visible_Restrict_Revive)
{
return true;
}
return false;
}
}
public PB_Revive(PlayerBotBrain brain)
: base(brain)
{
}
}
public class PB_Enemy : PB_Base
{
public struct EnemyDetectionData
{
public int m_amountOfSeenEnemies;
public int m_amountOfSeenEnemiesClose;
public int m_amountOfSeenOneShotEnemiesClose;
public int m_amountOfSeenOneShotEnemies;
public float m_closestEnemyInBounds;
public EnemyAgent m_closestEnemy;
public bool m_AggressiveEnemyFound;
}
private EnemyDetectionData m_detectData;
public EnemyDetectionData EnemyDetection => m_detectData;
public PB_Enemy(PlayerBotBrain brain)
: base(brain)
{
}
public override void UpdateBrain()
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Invalid comparison between Unknown and I4
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: 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 (((Agent)m_brain.Agent).CourseNode == null)
{
m_detectData = default(EnemyDetectionData);
return;
}
List<EnemyAgent> reachableEnemiesInNodes = AIG_CourseGraph.GetReachableEnemiesInNodes(((Agent)m_brain.Agent).CourseNode, 3);
EnemyDetectionData detectData = default(EnemyDetectionData);
detectData.m_AggressiveEnemyFound = false;
for (int i = 0; i < reachableEnemiesInNodes.Count; i++)
{
EnemyAgent val = reachableEnemiesInNodes[i];
if (!((Agent)val).Alive || (int)((AgentAI)val.AI).Mode != 1)
{
continue;
}
bool num = m_brain.Agent.CanSeeObject(((Agent)m_brain.Agent).EyePosition, ((Component)val).gameObject);
float num2 = Vector3.Distance(((Agent)m_brain.Agent).Position, val.Position);
bool flag = (double)m_brain.Agent.PlayerData.health * 0.15 < (double)val.EnemyBalancingData.MeleeAttackDamage;
if (!detectData.m_AggressiveEnemyFound || detectData.m_closestEnemyInBounds > num2)
{
detectData.m_closestEnemyInBounds = num2;
detectData.m_AggressiveEnemyFound = true;
detectData.m_closestEnemy = val;
}
if (!num)
{
continue;
}
detectData.m_amountOfSeenEnemies++;
if (flag)
{
detectData.m_amountOfSeenOneShotEnemies++;
}
if (num2 < 8f)
{
detectData.m_amountOfSeenEnemiesClose++;
if (flag)
{
detectData.m_amountOfSeenOneShotEnemiesClose++;
}
}
}
m_detectData = detectData;
}
}
public class PlayerBotActionCollection
{
public PlayerBotActionHighlight HighLight;
public PlayerBotActionIdle Idle;
public PlayerBotActionFollow Follow;
public PlayerBotActionUseBioscan UseBioScan;
public PlayerBotActionAttack Attack;
public PlayerBotActionRevive Revive;
public PlayerBotActionUseEnemyScanner UseEnemyScanner;
public PlayerBotActionUseEnemyScanner TagEnemies;
public PlayerBotActionCollectItem CollectItem;
public PlayerBotActionShareResourcePack ShareResourcePack;
public void OnSetupRootAction(RootPlayerBotAction rootAction)
{
HighLight = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionHighlight>();
Idle = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionIdle>();
Follow = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionFollow>();
UseBioScan = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionUseBioscan>();
Attack = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionAttack>();
Revive = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionRevive>();
UseEnemyScanner = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionUseEnemyScanner>();
TagEnemies = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionUseEnemyScanner>();
CollectItem = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionCollectItem>();
ShareResourcePack = ((Il2CppObjectBase)((Descriptor)rootAction.m_highlightAction).ActionBase).TryCast<PlayerBotActionShareResourcePack>();
}
}
public class PlayerBotBrain
{
public PB_Revive m_reviveBrain;
public PB_Damage m_damageBrain;
public PB_Enemy m_enemyBrain;
public PB_Friendlies m_friendliesBrain;
public PB_UnlockResourceContainer m_unlockResourceContainerBrain;
private PlayerAgent m_agent;
public PlayerAgent Agent => m_agent;
public Vector3 EyePosition => ((Agent)m_agent).EyePosition;
public bool IsTakingDamage => m_damageBrain.IsTakingDamage;
public bool ForceBulletsOnly
{
get
{
if (HasAmmo())
{
if (IsTakingDamage)
{
return true;
}
if (m_enemyBrain.EnemyDetection.m_amountOfSeenOneShotEnemies > 0)
{
return true;
}
if (m_enemyBrain.EnemyDetection.m_amountOfSeenEnemies > 2)
{
return true;
}
}
return false;
}
}
public bool ForceAvoidStance
{
get
{
if (IsTakingDamage)
{
return true;
}
if (m_enemyBrain.EnemyDetection.m_amountOfSeenOneShotEnemies > 0)
{
return true;
}
if (m_enemyBrain.EnemyDetection.m_amountOfSeenEnemies > 3)
{
return true;
}
return false;
}
}
public bool RestrictHighlightingItems => m_enemyBrain.EnemyDetection.m_amountOfSeenEnemiesClose > 0;
public bool ReviveRestricted => m_reviveBrain.ReviveIsDangerous;
public void Setup(PlayerAgent agent)
{
m_agent = agent;
m_reviveBrain = new PB_Revive(this);
m_damageBrain = new PB_Damage(this);
m_enemyBrain = new PB_Enemy(this);
m_friendliesBrain = new PB_Friendlies(this);
m_unlockResourceContainerBrain = new PB_UnlockResourceContainer(this);
}
public void Update()
{
m_enemyBrain.UpdateBrain();
m_reviveBrain.UpdateBrain();
m_damageBrain.UpdateBrain();
m_friendliesBrain.UpdateBrain();
m_unlockResourceContainerBrain.UpdateBrain();
}
public bool TryToGetBioScanOnPlayerAgent(PlayerAgent playerAgent, out CP_Bioscan_Core selectedCore)
{
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Invalid comparison between Unknown and I4
selectedCore = null;
List<ChainedPuzzleInstance> instances = ChainedPuzzleManager.Current.m_instances;
if (instances == null)
{
return false;
}
for (int i = 0; i < instances.Count; i++)
{
ChainedPuzzleInstance val = instances[i];
if (!((Object)(object)val != (Object)null))
{
continue;
}
Il2CppReferenceArray<iChainedPuzzleCore> chainedPuzzleCores = val.m_chainedPuzzleCores;
if (chainedPuzzleCores == null || ((Il2CppArrayBase<iChainedPuzzleCore>)(object)chainedPuzzleCores).Count <= 0)
{
continue;
}
for (int j = 0; j < ((Il2CppArrayBase<iChainedPuzzleCore>)(object)chainedPuzzleCores).Count; j++)
{
if (((Il2CppArrayBase<iChainedPuzzleCore>)(object)chainedPuzzleCores)[j] == null)
{
continue;
}
CP_Bioscan_Core val2 = ((Il2CppObjectBase)((Il2CppArrayBase<iChainedPuzzleCore>)(object)chainedPuzzleCores)[j]).TryCast<CP_Bioscan_Core>();
if ((Object)(object)val2 != (Object)null)
{
CP_PlayerScanner val3 = ((Il2CppObjectBase)val2.PlayerScanner).TryCast<CP_PlayerScanner>();
if ((Object)(object)val3 != (Object)null && (int)val3.ScanPlayersRequired == 1 && val2.PlayersOnScan.ToList<PlayerAgent>().Contains(playerAgent))
{
selectedCore = val2;
}
}
}
}
return (Object)(object)selectedCore != (Object)null;
}
public float GetAmmoRel(PlayerBackpack backPack, AmmoType ammoType)
{
//IL_0006: 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_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Invalid comparison between Unknown and I4
float ammoInPack = backPack.AmmoStorage.GetAmmoInPack(ammoType);
if ((int)ammoType != 0)
{
if ((int)ammoType == 1)
{
return backPack.AmmoStorage.GetClipAmmoFromSlot((InventorySlot)2) + ammoInPack;
}
return 0f;
}
return backPack.AmmoStorage.GetClipAmmoFromSlot((InventorySlot)1) + ammoInPack;
}
public bool HasAmmo()
{
PlayerBackpack backpack = PlayerBackpackManager.GetBackpack(m_agent.Owner);
BackpackItem val = default(BackpackItem);
if (backpack.TryGetBackpackItem((InventorySlot)1, ref val) && GetAmmoRel(backpack, (AmmoType)0) > 0f)
{
return true;
}
if (backpack.TryGetBackpackItem((InventorySlot)2, ref val) && GetAmmoRel(backpack, (AmmoType)1) > 0f)
{
return true;
}
return false;
}
}
public class PB_UnlockResourceContainer : PB_Base
{
private LG_ResourceContainer_Storage m_targetContainer;
public bool HasTargetContainer => (Object)(object)m_targetContainer != (Object)null;
public PB_UnlockResourceContainer(PlayerBotBrain brain)
: base(brain)
{
}
public void SetTargetResourceContainer(LG_ResourceContainer_Storage targetContainer)
{
m_targetContainer = targetContainer;
}
public void OpenTargetContainer()
{
if (!((Object)(object)m_targetContainer == (Object)null))
{
LG_WeakResourceContainer component = ((Component)m_targetContainer).gameObject.GetComponent<LG_WeakResourceContainer>();
if (!component.ISOpen && !component.IsLocked())
{
component.OnWeakLockUnlocked(true);
}
m_targetContainer = null;
}
}
}
}
namespace BetterBots.Components
{
[IL2CPP_ComponentDescriptor(m_dontDestroyOnLoad = true, m_launchOnStartLoad = false)]
public class BotRecorder : MonoBehaviorFixed
{
public Rect m_guiSlot;
public int m_guiSlotIndex;
private PlayerAIBot m_bot;
private RootPlayerBotAction m_rootAction;
private PlayerBotBrain m_brain;
private bool m_hasRootAction;
private string m_botName;
private PlayerBotActionCollection m_actionCollection;
private PlayerBotForcedUnlockAction m_forcedUnlockAction;
public float m_abortExpeditionItemTimer;
public bool m_firstExpeditionItemTimer;
private PlayerBotActionDebugBase[] m_actiondebugs;
private GUIStyle m_recorderStyle;
public bool m_hasGuiSlot;
[HideFromIl2Cpp]
public PlayerBotBrain Brain => m_brain;
[HideFromIl2Cpp]
public PlayerAgent Agent => m_agent;
[HideFromIl2Cpp]
public RootPlayerBotAction RootAction => m_rootAction;
[HideFromIl2Cpp]
public bool HasRootAction => m_hasRootAction;
[HideFromIl2Cpp]
public PlayerBotForcedUnlockAction ForcedUnlockAction => m_forcedUnlockAction;
[HideFromIl2Cpp]
public bool SneakingRestricted
{
get
{
if (!Brain.m_enemyBrain.EnemyDetection.m_AggressiveEnemyFound)
{
return false;
}
if (Brain.m_enemyBrain.EnemyDetection.m_amountOfSeenEnemiesClose > 0)
{
return true;
}
if (Brain.m_enemyBrain.EnemyDetection.m_closestEnemyInBounds < 10f)
{
return true;
}
return false;
}
}
[HideFromIl2Cpp]
private PlayerAgent m_agent => m_bot.Agent;
[HideFromIl2Cpp]
private string Preffix => "Bot: <color=#" + ColorUtility.ToHtmlStringRGB(m_agent.Owner.PlayerColor) + ">" + m_botName + "</color> ";
[HideFromIl2Cpp]
private string GetLogInfo
{
get
{
List<string> val = new List<string>();
GetActionDebug(PlayerBotActionType.Idle, val);
GetActionDebug(PlayerBotActionType.Follow, val);
GetActionDebug(PlayerBotActionType.UseBioScan, val);
GetActionDebug(PlayerBotActionType.Attack, val);
GetActionDebug(PlayerBotActionType.UseFireArm, val);
GetActionDebug(PlayerBotActionType.Revive, val);
GetActionDebug(PlayerBotActionType.ShareResource, val);
GetActionDebug(PlayerBotActionType.CollectItem, val);
GetActionDebug(PlayerBotActionType.CarryExpedtionItem, val);
string text = "<b><color=yellow>Active Actions</color></b>\n";
Enumerator<string> enumerator = val.GetEnumerator();
while (enumerator.MoveNext())
{
string current = enumerator.Current;
text += current;
}
return text;
}
}
private void Awake()
{
Setup();
}
[HideFromIl2Cpp]
public bool HasLockMelters()
{
BackpackItem val = default(BackpackItem);
if (!PlayerBackpackManager.GetBackpack(m_bot.Agent.Owner).TryGetBackpackItem((InventorySlot)5, ref val))
{
return false;
}
if (val.ItemID != 116)
{
return false;
}
return true;
}
[HideFromIl2Cpp]
public void ForceUnlockAction(LG_WeakResourceContainer storage, eWeakLockType lockType)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
m_forcedUnlockAction.ForceUnlockAction(storage, lockType, m_rootAction.m_unlockAction);
}
private void Setup()
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
m_firstExpeditionItemTimer = false;
m_actionCollection = new PlayerBotActionCollection();
m_rootAction = null;
m_hasRootAction = false;
m_bot = ((Component)this).GetComponent<PlayerAIBot>();
m_botName = m_bot.Agent.Owner.NickName;
m_forcedUnlockAction = new PlayerBotForcedUnlockAction(m_bot);
SetupActionDebugs();
m_recorderStyle = new GUIStyle();
m_recorderStyle.fontSize = 20;
m_recorderStyle.normal.textColor = Color.white;
m_brain = new PlayerBotBrain();
m_brain.Setup(m_bot.Agent);
BotRecorderManager.RegisterBotRecorder(this);
PlayerBotManagerExtended.RegisterBotRecoder(this);
if ((Object)(object)m_bot == (Object)null)
{
BBLog.Error("Could not get PlayerAIBot component!!");
}
}
private void SetupActionDebugs()
{
m_actiondebugs = new PlayerBotActionDebugBase[typeof(PlayerBotActionType).GetEnumValues().Length];
m_actiondebugs[1] = new PBAD_Follow();
m_actiondebugs[9] = new PBAD_UseFireArm();
m_actiondebugs[5] = new PBAD_UseBioScan();
m_actiondebugs[2] = new PBAD_Attack();
m_actiondebugs[6] = new PBAD_CollectItem();
m_actiondebugs[7] = new PBAD_CarryExpeditionItem();
m_actiondebugs[8] = new PBAD_Melee();
}
private void Update()
{
if (SNet.IsMaster)
{
CheckRootAction();
if (m_hasRootAction)
{
m_brain.Update();
UpdateCarryExpeditionItem();
UpdateReviveAction();
UpdateShareResourceAction();
UpdateCollectItemAction();
UpdateUseBioScanAction();
UpdateHighlightAction();
UpdateDeployTripMineAction();
CheckFollowAction();
}
}
}
private bool TryToGetBackPackItem(InventorySlot slot, out BackpackItem item)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
return PlayerBackpackManager.GetBackpack(m_agent.Owner).TryGetBackpackItem(slot, ref item);
}
private void UpdateCarryExpeditionItem()
{
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
if (!IsDangerousToContinueHoldingExpeditionItem() || !m_bot.TryGetActionDescriptor<Descriptor>(queued: true, active: true, out Descriptor targetDesc))
{
return;
}
PlayerBotActionCarryExpeditionItem val = ((Il2CppObjectBase)((Descriptor)targetDesc).ActionBase).TryCast<PlayerBotActionCarryExpeditionItem>();
if (val != null)
{
val.SetState((State)0);
m_bot.StopAction((Descriptor)(object)val.m_collectAction);
BackpackItem val2 = default(BackpackItem);
if (val.m_isCarrying && ((PlayerBotActionBase)val).m_backpack.TryGetBackpackItem((InventorySlot)8, ref val2) && Object.op_Implicit((Object)(object)val2.Instance))
{
PlayerBackpackManager.WantToDropItem(m_agent.Owner, val2.Instance.Get_pItemData(), ((Agent)m_agent).Position, ((Agent)m_agent).Rotation, true);
val.m_isCarrying = false;
}
m_abortExpeditionItemTimer = Time.time;
m_firstExpeditionItemTimer = true;
}
}
private void UpdateDeployTripMineAction()
{
}
[HideFromIl2Cpp]
public bool IsInDangerousSituation()
{
if (!Brain.m_damageBrain.IsTakingDamage)
{
return Brain.m_enemyBrain.EnemyDetection.m_amountOfSeenEnemies > 3;
}
return true;
}
[HideFromIl2Cpp]
public bool IsDangerousToContinueHoldingExpeditionItem()
{
if (!Brain.m_damageBrain.IsTakingDamage && Brain.m_enemyBrain.EnemyDetection.m_amountOfSeenEnemiesClose <= 0)
{
return Brain.m_enemyBrain.EnemyDetection.m_amountOfSeenOneShotEnemiesClose > 0;
}
return true;
}
[HideFromIl2Cpp]
public bool IsDangerousToCollectExpeditionItem()
{
if (!Brain.m_damageBrain.IsTakingDamage && Brain.m_enemyBrain.EnemyDetection.m_amountOfSeenEnemiesClose <= 0)
{
return Brain.m_enemyBrain.EnemyDetection.m_amountOfSeenOneShotEnemiesClose > 0;
}
return true;
}
private void UpdateShareResourceAction()
{
if (m_rootAction.m_shareResourceAction != null && !((Descriptor)m_rootAction.m_shareResourceAction).IsTerminated() && IsInDangerousSituation())
{
((PlayerBotActionBase)m_rootAction).SafeStopAction((Descriptor)(object)m_rootAction.m_shareResourceAction);
}
}
private void CheckFollowAction()
{
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Invalid comparison between Unknown and I4
//IL_00b8: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: 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)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: 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_012b: 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_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Expected I4, but got Unknown
//IL_0169: 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_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
if (m_rootAction.m_followLeaderAction == null || (Object)(object)m_rootAction.m_followLeaderAction.Client == (Object)null || !((Agent)m_agent).Alive || ((Agent)m_agent).CourseNode == null)
{
return;
}
PlayerAgent client = m_rootAction.m_followLeaderAction.Client;
if (((Agent)client).CourseNode != null && ((Agent)client).Alive && !TryToGetBackPackItem((InventorySlot)8, out var _) && !PlayerBotManagerExtended.IsBotCurrentlyBusyWithAction(m_bot) && (int)GameStateManager.CurrentStateName == 10)
{
float num = 20f;
if ((Object)(object)((Agent)m_agent).CourseNode.m_area != (Object)(object)((Agent)client).CourseNode.m_area)
{
num = 10f;
}
if (Vector3.Distance(((Agent)client).Position, ((Agent)m_agent).Position) > num && ((Descriptor)m_rootAction.m_followLeaderAction).ActionBase != null && TryToGetRandomNavmeshLocation(((Agent)client).Position, 5f, out var finalPosition))
{
m_agent.WarpTo(finalPosition, ((Agent)client).Rotation, new pPlayerLocationData
{
lookDir = ((Agent)m_agent).TargetLookDir,
courseNode = new pCourseNode
{
courseNodeIDPlusOne = (byte)((Agent)m_agent).CourseNode.NodeID
},
plocStateReferenceID = (int)m_agent.Locomotion.m_currentStateEnum,
goodPosition = finalPosition,
plocState = m_agent.Locomotion.m_currentStateEnum
});
}
}
}
public bool TryToGetRandomNavmeshLocation(Vector3 fromPos, float radius, out Vector3 finalPosition)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: 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)
finalPosition = Vector3.zero;
NavMeshHit val = default(NavMeshHit);
if (NavMesh.SamplePosition(Random.insideUnitSphere * radius + fromPos, ref val, radius, -1))
{
finalPosition = ((NavMeshHit)(ref val)).position;
return true;
}
return false;
}
[HideFromIl2Cpp]
private void UpdateUseBioScanAction()
{
if (m_rootAction.m_useBioscanAction != null && ((Descriptor)m_rootAction.m_useBioscanAction).IsTerminated() && m_rootAction.m_followLeaderAction != null && (Object)(object)m_rootAction.m_followLeaderAction.Client != (Object)null && m_rootAction.m_followLeaderAction.Client.IsInBioscan && m_brain.TryToGetBioScanOnPlayerAgent(m_rootAction.m_followLeaderAction.Client, out var selectedCore))
{
((Descriptor)m_rootAction.m_useBioscanAction).Prio = RootPlayerBotAction.m_prioSettings.UseBioscan;
m_rootAction.m_useBioscanAction.Bioscan = selectedCore;
if (m_bot.RequestAction((Descriptor)(object)m_rootAction.m_useBioscanAction))
{
BBLog.Warn(m_botName + " forcing to go to following agent since they are going rogue...");
}
else
{
BBLog.Error(m_botName + " tried to be forced to go to following agent since they are going rogue...");
}
}
}
[HideFromIl2Cpp]
private void ForceBulletAttack()
{
PlayerBotActionAttack val = ((Il2CppObjectBase)((Descriptor)m_rootAction.m_attackAction).ActionBase).TryCast<PlayerBotActionAttack>();
if (val != null)
{
val.m_desc.Means = (AttackMeansEnum)4;
val.m_desc.Stance = (StanceEnum)1;
}
}
[HideFromIl2Cpp]
private void ForceMeleeAttack()
{
PlayerBotActionAttack val = ((Il2CppObjectBase)((Descriptor)m_rootAction.m_attackAction).ActionBase).TryCast<PlayerBotActionAttack>();
if (val != null)
{
val.m_desc.Means = (AttackMeansEnum)1;
}
}
[HideFromIl2Cpp]
private void UpdateCollectItemAction()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
if (m_rootAction.m_collectItemAction == null || ((Descriptor)m_rootAction.m_collectItemAction).IsTerminated())
{
return;
}
if ((Object)(object)m_rootAction.m_collectItemAction.TargetContainer != (Object)null)
{
LG_ResourceContainer_Storage targetContainer = m_rootAction.m_collectItemAction.TargetContainer;
if (((PlayerBotActionBase)m_rootAction).IsAnyHumanPlayerNear(((Component)targetContainer).transform.position, 5f))
{
((PlayerBotActionBase)m_rootAction).SafeStopAction((Descriptor)(object)m_rootAction.m_collectItemAction);
return;
}
}
m_rootAction.m_collectItemAction.Haste = ((DramaManager.GoToCombat || DramaManager.GoToEncounter) ? 2f : 0.5f);
}
[HideFromIl2Cpp]
private void UpdateHighlightAction()
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Invalid comparison between Unknown and I4
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Invalid comparison between Unknown and I4
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
if (m_rootAction.m_highlightAction == null || ((Descriptor)m_rootAction.m_highlightAction).IsTerminated())
{
return;
}
Descriptor highlightAction = m_rootAction.m_highlightAction;
if ((int)((Descriptor)highlightAction).Status == 2)
{
if (!Brain.m_unlockResourceContainerBrain.HasTargetContainer)
{
LG_ResourceContainer_Storage componentInParent = highlightAction.TargetGO.GetComponentInParent<LG_ResourceContainer_Storage>();
if ((Object)(object)componentInParent != (Object)null)
{
Brain.m_unlockResourceContainerBrain.SetTargetResourceContainer(componentInParent);
}
}
else
{
PlayerBotActionHighlight val = ((Il2CppObjectBase)((Descriptor)highlightAction).ActionBase).TryCast<PlayerBotActionHighlight>();
if (val != null && (int)val.m_state == 2)
{
Brain.m_unlockResourceContainerBrain.OpenTargetContainer();
}
}
}
bool flag = false;
if (m_brain.RestrictHighlightingItems)
{
flag = true;
}
else if ((DramaManager.GoToCombat || DramaManager.GoToEncounter) && m_rootAction.m_followLeaderAction != null && (Object)(object)m_rootAction.m_followLeaderAction.Client != (Object)null && Vector3.Distance(((Agent)m_agent).Position, ((Agent)m_rootAction.m_followLeaderAction.Client).Position) > 20f)
{
flag = true;
}
if (flag)
{
m_bot.StopAction((Descriptor)(object)m_rootAction.m_highlightAction);
}
}
[HideFromIl2Cpp]
private void StopReviveActions(PlayerBotActionRevive action)
{
m_bot.StopAction((Descriptor)(object)action.m_desc);
if (action.m_lookAction != null && !((Descriptor)action.m_lookAction).IsTerminated())
{
m_bot.StopAction((Descriptor)(object)action.m_lookAction);
}
if (action.m_travelAction != null && !((Descriptor)action.m_travelAction).IsTerminated())
{
m_bot.StopAction((Descriptor)(object)action.m_travelAction);
}
}
[HideFromIl2Cpp]
private void UpdateReviveAction()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Invalid comparison between Unknown and I4
if (m_rootAction.m_reviveAction == null || ((Descriptor)m_rootAction.m_reviveAction).IsTerminated())
{
return;
}
Descriptor reviveAction = m_rootAction.m_reviveAction;
PlayerBotActionBase actionBase = ((Descriptor)reviveAction).ActionBase;
PlayerBotActionRevive val = ((actionBase != null) ? ((Il2CppObjectBase)actionBase).TryCast<PlayerBotActionRevive>() : null);
if (!m_brain.ReviveRestricted || val == null)
{
return;
}
bool flag = false;
if ((int)val.m_state == 2)
{
if ((Object)(object)reviveAction.Client == (Object)null || (Object)(object)reviveAction.Client.ReviveInteraction == (Object)null || ((Interact_Timed)reviveAction.Client.ReviveInteraction).InteractionTimerRel < 0.5f)
{
flag = true;
}
}
else
{
flag = true;
}
if (flag)
{
StopReviveActions(val);
ForceFollowBestPlayerAgent();
}
}
[HideFromIl2Cpp]
private void ForceFollowBestPlayerAgent()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Invalid comparison between Unknown and I4
if (m_rootAction.m_followLeaderAction == null || (int)((Descriptor)m_rootAction.m_followLeaderAction).Status == 2)
{
return;
}
bool flag = false;
PlayerAgent otherPlayer;
if ((Object)(object)((PlayerBotActionBase)m_rootAction).m_bot.SyncValues.Leader != (Object)null)
{
flag = true;
m_rootAction.m_followLeaderAction.Client = ((PlayerBotActionBase)m_rootAction).m_bot.SyncValues.Leader;
}
else if (PlayerBotManagerExtended.TryToGetClosestPlayerAgentToPlayer(m_agent, out otherPlayer))
{
flag = true;
m_rootAction.m_followLeaderAction.Client = otherPlayer;
m_bot.SyncValues.Leader = otherPlayer;
}
if (flag)
{
if (m_bot.RequestAction((Descriptor)(object)m_rootAction.m_followLeaderAction))
{
BBLog.Message(m_botName + " is now force following " + m_bot.SyncValues.Leader.Owner.NickName);
}
else
{
BBLog.Error(m_botName + " tried to force follow " + m_bot.SyncValues.Leader.Owner.NickName + " but is busy with other actions!");
}
}
}
[HideFromIl2Cpp]
private void CheckRootAction()
{
if (m_bot.m_rootAction == null)
{
m_hasRootAction = false;
return;
}
if (m_bot.m_rootAction.ActionBase == null)
{
m_hasRootAction = false;
return;
}
RootPlayerBotAction val = ((Il2CppObjectBase)m_bot.m_rootAction.ActionBase).TryCast<RootPlayerBotAction>();
if (val == null)
{
m_hasRootAction = false;
return;
}
m_rootAction = val;
m_hasRootAction = true;
}
[HideFromIl2Cpp]
private void GetActionDebug(PlayerBotActionType type, List<string> actionsList)
{
if ((Object)(object)m_bot == (Object)null && m_bot.m_actions == null && m_bot.m_actions.Count == 0)
{
return;
}
PlayerBotActionDebugBase playerBotActionDebugBase = m_actiondebugs[(int)type];
if (playerBotActionDebugBase == null)
{
return;
}
Enumerator<PlayerBotActionBase> enumerator = m_bot.m_actions.GetEnumerator();
while (enumerator.MoveNext())
{
PlayerBotActionBase current = enumerator.Current;
if (current != null && playerBotActionDebugBase.ActionType != (Type)null && playerBotActionDebugBase.ActionType == ((Object)current).GetIl2CppType())
{
playerBotActionDebugBase.PrintFields(current);
actionsList.Add(playerBotActionDebugBase.Message);
}
}
}
private void OnGUI()
{
}
[HideFromIl2Cpp]
private void OnDestroy()
{
BotRecorderManager.DeRegisterRecorder(this);
PlayerBotManagerExtended.DeRegisterBotRecorder(this);
BBLog.Warn("BotRecorder Destroyed!! - " + m_botName);
}
public BotRecorder(IntPtr pointer)
: base(pointer)
{
}
}
public class MonoBehaviorFixed : MonoBehaviour
{
public MonoBehaviorFixed()
{
}
public MonoBehaviorFixed(IntPtr pointer)
: base(pointer)
{
}
}
public class PlayerBotDevWheel : MonoBehaviorFixed
{
private void Update()
{
if (Input.GetKeyDown((KeyCode)286))
{
PlayerBotManagerExtended.TryToGetClosestPlayerAgentToPlayer(PlayerManager.GetLocalPlayerAgent(), out var otherPlayer);
PlayerAIBot component = ((Component)otherPlayer).GetComponent<PlayerAIBot>();
if ((Object)(object)component != (Object)null)
{
((Il2CppObjectBase)component.m_rootAction.ActionBase).TryCast<RootPlayerBotAction>();
}
}
}
}
[IL2CPP_ComponentDescriptor(m_dontDestroyOnLoad = true, m_launchOnStartLoad = true)]
public class PlayerBotManagerUpdater : MonoBehaviorFixed
{
public PlayerBotManagerUpdater()
{
}
public PlayerBotManagerUpdater(IntPtr pointer)
: base(pointer)
{
}
private void Update()
{
PlayerBotManagerExtended.Update();
}
private void FixedUpdate()
{
PlayerBotManagerExtended.FixedUpdate();
}
private void LateUpdate()
{
PlayerBotManagerExtended.LateUpdate();
}
private void Start()
{
PlayerBotManagerExtended.Start();
}
private void Awake()
{
PlayerBotManagerExtended.Awake();
}
}
}
namespace BetterBots.Attributes
{
[AttributeUsage(AttributeTargets.Class)]
public class IL2CPP_ComponentDescriptorAttribute : Attribute
{
public bool m_launchOnStartLoad;
public bool m_dontDestroyOnLoad;
}
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class PBD_Data : Attribute
{
public PlayerBotActionType ActionType;
}
}
