using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AIGraph;
using API;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Enemies;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Microsoft.CodeAnalysis;
using MindControl.BepInEx;
using Player;
using ReplayRecorder;
using ReplayRecorder.Net;
using SNetwork;
using StateMachines;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MindControl")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+91c81a4b4726217314e44288a66a576e540178aa")]
[assembly: AssemblyProduct("MindControl")]
[assembly: AssemblyTitle("MindControl")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace API
{
internal static class APILogger
{
private static readonly ManualLogSource logger;
static APILogger()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
logger = new ManualLogSource("Rand-API");
Logger.Sources.Add((ILogSource)(object)logger);
}
private static string Format(string module, object msg)
{
return $"[{module}]: {msg}";
}
public static void Info(string module, object data)
{
logger.LogMessage((object)Format(module, data));
}
public static void Verbose(string module, object data)
{
}
public static void Log(object data)
{
logger.LogDebug((object)Format("MindControl", data));
}
public static void Debug(object data)
{
if (ConfigManager.Debug)
{
Log(data);
}
}
public static void Warn(object data)
{
logger.LogWarning((object)Format("MindControl", data));
}
public static void Error(object data)
{
logger.LogError((object)Format("MindControl", data));
}
}
}
namespace MindControl
{
[HarmonyPatch]
public class EnemyController : MonoBehaviour
{
[HarmonyPatch]
internal static class Patches
{
public static bool DontRecurse = false;
private static bool patch = true;
[HarmonyPatch(typeof(EnemySync), "OnSpawn")]
[HarmonyPostfix]
private static void Postfix_OnSpawn(EnemySync __instance, pEnemySpawnData spawnData)
{
if (SNet.IsMaster)
{
EnemyAgent agent = __instance.m_agent;
if (!((Object)(object)((Component)agent).GetComponent<PouncerBehaviour>() != (Object)null) && !agent.EnemyBehaviorData.IsFlyer)
{
((Component)agent).gameObject.AddComponent<EnemyController>().AssignAgent(agent);
}
}
}
[HarmonyPatch(typeof(EnemyBehaviour), "UpdateState")]
[HarmonyPrefix]
private static void Prefix_UpdateState(EnemyBehaviour __instance)
{
if (!DontRecurse && !(__instance.m_updatebehaviour >= Clock.Time) && controllers.TryGetValue(((Agent)__instance.m_ai.m_enemyAgent).GlobalID, out EnemyController value))
{
value.UpdateBehaviour();
}
}
[HarmonyPatch(typeof(EB_InCombat_MoveToPoint), "UpdateBehaviour")]
[HarmonyPrefix]
private static bool Prefix_UpdateBehaviour(EB_InCombat_MoveToPoint __instance)
{
if (!SNet.IsMaster)
{
return true;
}
EnemyAI ai = ((EB_StateBase)__instance).m_ai;
if (!controllers.TryGetValue(((Agent)ai.m_enemyAgent).GlobalID, out EnemyController value) || !value.IsControlled)
{
return true;
}
if (value.commandBuffer.Peek().type == Command.Type.Attack)
{
return true;
}
return false;
}
[HarmonyPatch(typeof(EnemyCourseNavigation), "UpdateTracking")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void UpdateTracking(EnemyCourseNavigation __instance)
{
if (!patch || !SNet.IsMaster)
{
return;
}
EnemyAI aI = __instance.m_owner.AI;
if (controllers.TryGetValue(((Agent)aI.m_enemyAgent).GlobalID, out EnemyController value) && value.IsControlled)
{
Command command = value.commandBuffer.Peek();
if (command.type == Command.Type.Attack && (Object)(object)command.target != (Object)null)
{
patch = false;
((AgentAI)aI).SetTarget((Agent)(object)command.target);
patch = true;
}
else if (command.type == Command.Type.MoveAttack && (Object)(object)value.currentTarget != (Object)null)
{
patch = false;
((AgentAI)aI).SetTarget((Agent)(object)value.currentTarget);
patch = true;
}
}
}
[HarmonyPatch(typeof(EB_InCombat), "TryAttacks")]
[HarmonyPrefix]
private static bool Prefix_TryAttacks(EB_InCombat __instance, ref bool __result)
{
if (!SNet.IsMaster)
{
return true;
}
EnemyAI ai = ((EB_StateBase)__instance).m_ai;
if (!controllers.TryGetValue(((Agent)ai.m_enemyAgent).GlobalID, out EnemyController value) || !value.IsControlled)
{
return true;
}
Command.Type type = value.commandBuffer.Peek().type;
if ((uint)(type - 1) <= 1u)
{
return true;
}
__result = false;
return false;
}
[HarmonyPatch(typeof(EB_InCombat), "TryStrafe")]
[HarmonyPrefix]
private static bool Prefix_TryStrafe(EB_InCombat __instance, ref bool __result)
{
if (!SNet.IsMaster)
{
return true;
}
EnemyAI ai = ((EB_StateBase)__instance).m_ai;
if (!controllers.TryGetValue(((Agent)ai.m_enemyAgent).GlobalID, out EnemyController value) || !value.IsControlled)
{
return true;
}
if (value.commandBuffer.Peek().type == Command.Type.Attack)
{
if ((((AgentAI)ai).Abilities.HasAbility((AgentAbility)1) && !((AgentAI)ai).Abilities.IsAbilityReady((AgentAbility)1, 0)) || (((AgentAI)ai).Abilities.HasAbility((AgentAbility)2) && !((AgentAI)ai).Abilities.IsAbilityReady((AgentAbility)2, 0)))
{
return true;
}
__result = false;
return false;
}
__result = false;
return false;
}
[HarmonyPatch(typeof(EB_InCombat), "TryScream")]
[HarmonyPrefix]
private static bool Prefix_TryScream(EB_InCombat __instance, ref bool __result)
{
if (!SNet.IsMaster)
{
return true;
}
EnemyAI ai = ((EB_StateBase)__instance).m_ai;
if (!controllers.TryGetValue(((Agent)ai.m_enemyAgent).GlobalID, out EnemyController value) || !value.IsControlled)
{
return true;
}
__result = false;
return false;
}
}
public class Command
{
public enum Type
{
Move,
Attack,
MoveAttack
}
public Type type;
public PlayerAgent? target;
public Vector3 position;
public Vector3 destination;
public Command(Vector3 pos)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: 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)
type = Type.Move;
position = pos;
destination = pos;
}
public Command(PlayerAgent target)
{
type = Type.Attack;
this.target = target;
}
}
public static Dictionary<int, EnemyController> controllers = new Dictionary<int, EnemyController>();
private int globalId;
private EnemyAgent agent;
private EnemyAI ai;
private EnemyLocomotion locomotion;
private EnemyBehaviour behaviour;
private EnemyBehaviourData behaviourData;
private EB_InCombat EBInCombat;
public Queue<Command> commandBuffer = new Queue<Command>();
private PlayerAgent? currentTarget;
public bool IsControlled
{
get
{
if (agent.m_alive)
{
return commandBuffer.Count > 0;
}
return false;
}
}
public void AssignAgent(EnemyAgent agent)
{
this.agent = agent;
globalId = ((Agent)this.agent).GlobalID;
locomotion = agent.Locomotion;
ai = agent.AI;
behaviour = ai.m_behaviour;
EBInCombat = ((Il2CppObjectBase)((StateMachine<EB_StateBase>)(object)behaviour).m_states[5]).Cast<EB_InCombat>();
behaviourData = ai.m_behaviourData;
controllers.Add(globalId, this);
}
private void OnDestroy()
{
controllers.Remove(globalId);
}
public void AddPosition(Vector3 pos)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
commandBuffer.Enqueue(new Command(pos));
}
public void AddAttackPosition(Vector3 pos)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
Command command = new Command(pos);
command.type = Command.Type.MoveAttack;
commandBuffer.Enqueue(command);
}
public void AddTarget(PlayerAgent target)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
if (target.m_alive)
{
commandBuffer.Enqueue(new Command(target));
}
else
{
commandBuffer.Enqueue(new Command(((Agent)target).m_position));
}
}
public void ClearCommands()
{
if (commandBuffer.Count > 0)
{
commandBuffer.Clear();
behaviourData.m_advanceTimer = 0f;
Patches.DontRecurse = true;
behaviour.ChangeState((EB_States)5);
Patches.DontRecurse = false;
}
}
public void UpdateBehaviour()
{
if (IsControlled)
{
Command command = commandBuffer.Peek();
switch (command.type)
{
case Command.Type.Move:
case Command.Type.MoveAttack:
MoveCommand(command);
break;
case Command.Type.Attack:
AttackCommand(command);
break;
}
}
}
private void AttackCommand(Command command)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Invalid comparison between Unknown and I4
if ((int)((AgentAI)ai).Mode != 1)
{
((AgentAI)ai).Mode = (AgentMode)1;
((AgentAI)ai).ModeChange();
}
if (((Il2CppObjectBase)((StateMachine<EB_StateBase>)(object)behaviour).m_currentState).TryCast<EB_Hibernating>() != null)
{
locomotion.ChangeState((ES_StateEnum)2);
Patches.DontRecurse = true;
behaviour.ChangeState((EB_States)5);
Patches.DontRecurse = false;
}
behaviourData.m_advanceTimer = 0f;
if (!((Object)(object)command.target == (Object)null))
{
if (((AgentAI)ai).m_target == null || (Object)(object)((AgentAI)ai).m_target.m_agent == (Object)null || ((AgentAI)ai).m_target.m_agent.GlobalID != ((Agent)command.target).GlobalID)
{
((AgentAI)ai).SetTarget((Agent)(object)command.target);
}
if (!((Agent)command.target).Alive)
{
commandBuffer.Dequeue();
APILogger.Debug("Target dead!");
}
}
}
private void MoveCommand(Command command)
{
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Invalid comparison between Unknown and I4
//IL_0189: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Invalid comparison between Unknown and I4
//IL_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Invalid comparison between Unknown and I4
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0191: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Invalid comparison between Unknown and I4
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
//IL_0185: Invalid comparison between Unknown and I4
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
//IL_01a4: Invalid comparison between Unknown and I4
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_0205: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_015e: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Invalid comparison between Unknown and I4
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_0237: Unknown result type (might be due to invalid IL or missing references)
//IL_023d: Invalid comparison between Unknown and I4
//IL_0227: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Invalid comparison between Unknown and I4
//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
//IL_0302: Unknown result type (might be due to invalid IL or missing references)
//IL_0307: Unknown result type (might be due to invalid IL or missing references)
Vector3 val;
ES_StateEnum currentStateEnum;
if (command.type == Command.Type.MoveAttack)
{
if ((Object)(object)currentTarget != (Object)null)
{
float max = agent.EnemyBehaviorData.MeleeAttackDistance.Max;
float max2 = agent.EnemyBehaviorData.RangedAttackDistance.Max;
val = ((Agent)currentTarget).m_position - ((Agent)agent).m_position;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
if (((AgentAI)ai).Abilities.HasAbility((AgentAbility)1) && sqrMagnitude >= max && ((AgentAI)ai).Abilities.HasAbility((AgentAbility)2) && sqrMagnitude >= max2)
{
currentTarget = null;
}
}
if ((Object)(object)currentTarget == (Object)null)
{
float num = float.MaxValue;
Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator();
while (enumerator.MoveNext())
{
PlayerAgent current = enumerator.Current;
if (current.m_alive)
{
val = ((Agent)current).m_position - ((Agent)agent).m_position;
float sqrMagnitude2 = ((Vector3)(ref val)).sqrMagnitude;
if (sqrMagnitude2 < num)
{
num = sqrMagnitude2;
currentTarget = current;
}
}
}
}
if ((Object)(object)currentTarget != (Object)null && currentTarget.m_alive)
{
((AgentAI)ai).SetTarget((Agent)(object)currentTarget);
if (EBInCombat.TryAttacks())
{
return;
}
currentStateEnum = locomotion.CurrentStateEnum;
if (currentStateEnum - 18 <= 1 || (int)currentStateEnum == 23)
{
return;
}
}
}
currentStateEnum = locomotion.CurrentStateEnum;
if ((int)currentStateEnum <= 10)
{
if ((int)currentStateEnum == 7 || (int)currentStateEnum == 10)
{
return;
}
}
else if (currentStateEnum - 24 <= 1 || (int)currentStateEnum == 29)
{
return;
}
if ((int)((AgentAI)ai).Mode != 1)
{
((AgentAI)ai).Mode = (AgentMode)1;
((AgentAI)ai).ModeChange();
}
if (((AgentAI)ai).m_target == null || !((AgentAI)ai).m_target.m_hasLineOfSight)
{
EnemyAgent enemyAgent = ai.m_enemyAgent;
val = command.destination - ((Component)ai).transform.position;
((Agent)enemyAgent).TargetLookDir = ((Vector3)(ref val)).normalized;
}
else
{
((Agent)ai.m_enemyAgent).TargetLookDir = ((AgentAI)ai).m_target.m_dir;
}
if ((int)locomotion.CurrentStateEnum != 2)
{
locomotion.ChangeState((ES_StateEnum)2);
}
if (((Il2CppObjectBase)((StateMachine<EB_StateBase>)(object)behaviour).m_currentState).TryCast<EB_InCombat_MoveToPoint>() == null)
{
Patches.DontRecurse = true;
behaviour.ChangeState((EB_States)5);
behaviour.m_updatebehaviour = 0f;
((StateMachine<EB_StateBase>)(object)behaviour).UpdateState();
behaviour.ChangeState((EB_States)7);
behaviour.m_updatebehaviour = 0f;
((StateMachine<EB_StateBase>)(object)behaviour).UpdateState();
behaviour.ChangeState((EB_States)6);
Patches.DontRecurse = false;
}
EBInCombat.UpdateAvoidance();
if (((AgentAI)ai).m_navMeshAgent.isOnNavMesh)
{
((AgentAI)ai).m_navMeshAgent.destination = command.position;
command.destination = ((AgentAI)ai).m_navMeshAgent.destination;
}
}
}
}
namespace MindControl.BepInEx
{
public static class Module
{
public const string GUID = "randomuserhi.MindControl";
public const string Name = "MindControl";
public const string Version = "0.0.1";
}
public static class ConfigManager
{
public static ConfigFile configFile;
private static ConfigEntry<bool> debug;
public static bool Debug
{
get
{
return debug.Value;
}
set
{
debug.Value = value;
}
}
static ConfigManager()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
configFile = new ConfigFile(Path.Combine(Paths.ConfigPath, "MindControl.cfg"), true);
debug = configFile.Bind<bool>("Debug", "enable", false, "Enables debug messages when true.");
}
}
[BepInPlugin("randomuserhi.MindControl", "MindControl", "0.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BasePlugin
{
private enum CommandType
{
MindControlPosition,
MindControlClear,
MindControlAttack,
MindControlAttackPosition
}
private static Harmony? harmony;
public override void Load()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Expected O, but got Unknown
APILogger.Log("Plugin is loaded!");
harmony = new Harmony("randomuserhi.MindControl");
harmony.PatchAll();
ClassInjector.RegisterTypeInIl2Cpp<EnemyController>();
APILogger.Log("Debug is " + (ConfigManager.Debug ? "Enabled" : "Disabled"));
VNet.Register("MindControl", (Action<ulong, ArraySegment<byte>>)OnMindControlCommand);
VNet.Register("MindControl.SpawnEnemy", (Action<ulong, ArraySegment<byte>>)OnMindControlSpawnCommand);
}
private static AIG_CourseNode? GetNode(Vector3 position)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//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)
AIG_INode val = default(AIG_INode);
AIG_NodeCluster val2 = default(AIG_NodeCluster);
if (AIG_GeomorphNodeVolume.TryGetNode(0, Dimension.GetDimensionFromPos(position).DimensionIndex, position, ref val, false) && AIG_NodeCluster.TryGetNodeCluster(val.ClusterID, ref val2))
{
if (val2.CourseNode == null)
{
return null;
}
return val2.CourseNode;
}
return null;
}
private static void OnMindControlSpawnCommand(ulong from, ArraySegment<byte> buffer)
{
//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_001f: 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)
if (!SNet.IsMaster)
{
return;
}
int num = 0;
Vector3 pos = BitHelper.ReadHalfVector3(buffer, ref num);
Quaternion rot = Quaternion.identity;
uint id = BitHelper.ReadUInt(buffer, ref num);
MainThread.Run((Action)delegate
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
AIG_CourseNode val = GetNode(pos);
if (val == null)
{
val = ((Agent)PlayerManager.GetLocalPlayerAgent()).CourseNode;
}
EnemyAllocator.Current.SpawnEnemy(id, val, (AgentMode)4, pos, rot, (EnemyGroup)null, -1);
});
}
private static void OnMindControlCommand(ulong from, ArraySegment<byte> buffer)
{
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
if (!SNet.IsMaster)
{
return;
}
int index = 0;
CommandType commandType = (CommandType)BitHelper.ReadUShort(buffer, ref index);
APILogger.Debug($"Received command of type '{commandType}'.");
switch (commandType)
{
case CommandType.MindControlClear:
{
int numEnemies4 = BitHelper.ReadInt(buffer, ref index);
APILogger.Debug($"Num Enemies '{numEnemies4}'.");
MainThread.Run((Action)delegate
{
for (int i = 0; i < numEnemies4; i++)
{
ushort key = BitHelper.ReadUShort(buffer, ref index);
if (EnemyController.controllers.TryGetValue(key, out EnemyController value))
{
value.ClearCommands();
}
}
});
break;
}
case CommandType.MindControlPosition:
{
Vector3 pos2 = BitHelper.ReadHalfVector3(buffer, ref index);
int numEnemies3 = BitHelper.ReadInt(buffer, ref index);
APILogger.Debug($"Num Enemies '{numEnemies3}'.");
MainThread.Run((Action)delegate
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < numEnemies3; i++)
{
ushort key = BitHelper.ReadUShort(buffer, ref index);
if (EnemyController.controllers.TryGetValue(key, out EnemyController value))
{
value.ClearCommands();
value.AddPosition(pos2);
}
}
});
break;
}
case CommandType.MindControlAttackPosition:
{
Vector3 pos = BitHelper.ReadHalfVector3(buffer, ref index);
int numEnemies2 = BitHelper.ReadInt(buffer, ref index);
APILogger.Debug($"Num Enemies '{numEnemies2}'.");
MainThread.Run((Action)delegate
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < numEnemies2; i++)
{
ushort key = BitHelper.ReadUShort(buffer, ref index);
if (EnemyController.controllers.TryGetValue(key, out EnemyController value))
{
value.ClearCommands();
value.AddAttackPosition(pos);
}
}
});
break;
}
case CommandType.MindControlAttack:
{
byte slot = BitHelper.ReadByte(buffer, ref index);
int numEnemies = BitHelper.ReadInt(buffer, ref index);
APILogger.Debug($"Num Enemies '{numEnemies}'.");
MainThread.Run((Action)delegate
{
if (slot < ((Il2CppArrayBase<SNet_Slot>)(object)SNet.Slots.PlayerSlots).Length)
{
PlayerAgent val = ((Il2CppObjectBase)((Il2CppArrayBase<SNet_Slot>)(object)SNet.Slots.PlayerSlots)[(int)slot].player.m_playerAgent).TryCast<PlayerAgent>();
if ((Object)(object)val != (Object)null)
{
for (int i = 0; i < numEnemies; i++)
{
ushort key = BitHelper.ReadUShort(buffer, ref index);
if (EnemyController.controllers.TryGetValue(key, out EnemyController value))
{
value.ClearCommands();
value.AddTarget(val);
}
}
}
}
});
break;
}
default:
APILogger.Error($"No command defined for message of type '{commandType}'");
break;
}
}
}
}
