using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AIGraph;
using AK;
using Agents;
using BepInEx;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using EOSExt.LevelSpawnedSentry.Definition;
using EOSExt.LevelSpawnedSentry.Impl;
using EOSExt.LevelSpawnedSentry.PlayerGUIMessage;
using ExtraObjectiveSetup;
using ExtraObjectiveSetup.BaseClasses;
using ExtraObjectiveSetup.ExtendedWardenEvents;
using ExtraObjectiveSetup.Utils;
using FX_EffectSystem;
using FloLib.Infos;
using FloLib.Networks.Replications;
using GTFO.API;
using GameData;
using GameEvent;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSystem;
using LevelGeneration;
using Localization;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using TenChambers.EventHandlers;
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("Inas07.EOSExt.LevelSpawnedSentry")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+68b383eb50863993e1dba11bdd637c0fa0347729")]
[assembly: AssemblyProduct("Inas07.EOSExt.LevelSpawnedSentry")]
[assembly: AssemblyTitle("Inas07.EOSExt.LevelSpawnedSentry")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace EOSExt.LevelSpawnedSentry
{
public class LevelSpawnedSentryManager : GenericExpeditionDefinitionManager<LevelSpawnedSentryDefinition>
{
public enum LSS_WardenEvents
{
ChangeLSSState = 910
}
public static LevelSpawnedSentryManager Current { get; private set; }
protected override string DEFINITION_NAME => "LevelSpawnedSentry";
private Dictionary<string, LSS> LSSDict { get; } = new Dictionary<string, LSS>();
internal List<LSS> LSSInstances { get; } = new List<LSS>();
private void PrepareForBuild()
{
Clear();
if (!base.definitions.TryGetValue(base.CurrentMainLevelLayout, out var value))
{
return;
}
for (int i = 0; i < value.Definitions.Count; i++)
{
LevelSpawnedSentryDefinition levelSpawnedSentryDefinition = value.Definitions[i];
LSS lSS = LSS.Instantiate(levelSpawnedSentryDefinition, i);
LSSInstances.Add(lSS);
if (LSSDict.ContainsKey(levelSpawnedSentryDefinition.WorldEventObjectFilter))
{
EOSLogger.Warning("LevelSpawnSentry: found duplicate WorldEventObjectFilter '" + levelSpawnedSentryDefinition.WorldEventObjectFilter + "'");
}
LSSDict[levelSpawnedSentryDefinition.WorldEventObjectFilter] = lSS;
}
}
private void Clear()
{
LSSInstances.ForEach(delegate(LSS i)
{
i.Destroy();
});
LSSInstances.Clear();
LSSDict.Clear();
}
private LevelSpawnedSentryManager()
{
LevelAPI.OnBuildStart += PrepareForBuild;
LevelAPI.OnLevelCleanup += Clear;
}
static LevelSpawnedSentryManager()
{
Current = new LevelSpawnedSentryManager();
EOSWardenEventManager.Current.AddEventDefinition(LSS_WardenEvents.ChangeLSSState.ToString(), 910u, (Action<WardenObjectiveEventData>)ChangeLSSState);
}
private static void ChangeLSSState(WardenObjectiveEventData e)
{
if (!Current.LSSDict.TryGetValue(e.WorldEventObjectFilter, out var value))
{
EOSLogger.Error("ChangeLSSState: Cannot find LSS with name '" + e.WorldEventObjectFilter + "'");
}
else if (SNet.IsMaster)
{
bool targetEnemy = e.EnemyID == 0;
bool targetPlayer = e.SustainedEventSlotIndex > 0;
bool markerVisible = e.Count == 0;
bool canRefill = e.FogSetting == 0;
LSSSyncState lSSSyncState = new LSSSyncState(value.State);
lSSSyncState.Enabled = e.Enabled;
lSSSyncState.TargetEnemy = targetEnemy;
lSSSyncState.TargetPlayer = targetPlayer;
lSSSyncState.MarkerVisible = markerVisible;
lSSSyncState.CanRefill = canRefill;
lSSSyncState.Ammo = value.LSSComp.Sentry.Ammo;
LSSSyncState state = lSSSyncState;
value.StateReplicator.SetState(state);
}
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("Inas.EOSExt.LevelSpawnedSentry", "EOSExt.LevelSpawnedSentry", "1.1.3")]
public class EntryPoint : BasePlugin
{
public const string AUTHOR = "Inas";
public const string PLUGIN_NAME = "EOSExt.LevelSpawnedSentry";
public const string VERSION = "1.1.3";
private Harmony m_Harmony;
public override void Load()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
SetupManagers();
m_Harmony = new Harmony("EOSExt.LevelSpawnedSentry");
m_Harmony.PatchAll();
EOSLogger.Log("ExtraObjectiveSetup.LevelSpawnedSentry loaded.");
}
private void SetupManagers()
{
((GenericExpeditionDefinitionManager<LevelSpawnedSentryDefinition>)LevelSpawnedSentryManager.Current).Init();
}
}
public class LSS
{
[CompilerGenerated]
private sealed class <s_sync>d__35 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private int <i>5__2;
private WaitForSeconds <waitOutOfLevel>5__3;
private WaitForSeconds <waitInLevel>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <s_sync>d__35(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<waitOutOfLevel>5__3 = null;
<waitInLevel>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Invalid comparison between Unknown and I4
//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
//IL_01f9: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<i>5__2 = 0;
<waitOutOfLevel>5__3 = new WaitForSeconds(15f);
<waitInLevel>5__4 = null;
break;
case 1:
<>1__state = -1;
break;
case 2:
<>1__state = -1;
break;
}
if ((int)GameStateManager.CurrentStateName == 10)
{
if (SNet.IsMaster && LevelSpawnedSentryManager.Current.LSSInstances.Count > 0)
{
if (0 <= <i>5__2 && <i>5__2 < LevelSpawnedSentryManager.Current.LSSInstances.Count)
{
LSS lSS = LevelSpawnedSentryManager.Current.LSSInstances[<i>5__2];
if ((Object)(object)lSS.LSSComp == (Object)null)
{
EOSLogger.Error("LSSSync: found LSS without LSSComp: " + lSS.Def.WorldEventObjectFilter);
}
else
{
SentryGunInstance sentry = lSS.LSSComp.Sentry;
if ((Object)(object)sentry != (Object)null)
{
LSSSyncState state = lSS.StateReplicator.State;
if ((double)Math.Abs(sentry.Ammo - state.Ammo) > 0.0001)
{
LSSSyncState state2 = new LSSSyncState(state)
{
Ammo = sentry.Ammo
};
lSS.StateReplicator.SetState(state2);
}
}
}
}
if (<i>5__2 == LevelSpawnedSentryManager.Current.LSSInstances.Count - 1)
{
EOSLogger.Debug($"LSS: master synced {LevelSpawnedSentryManager.Current.LSSInstances.Count} in {15f} seconds");
}
<i>5__2 = (<i>5__2 + 1) % LevelSpawnedSentryManager.Current.LSSInstances.Count;
}
if (<waitInLevel>5__4 == null)
{
<waitInLevel>5__4 = new WaitForSeconds(15f / (float)Math.Max(1, LevelSpawnedSentryManager.Current.LSSInstances.Count));
}
<>2__current = <waitInLevel>5__4;
<>1__state = 1;
return true;
}
<waitInLevel>5__4 = null;
<>2__current = <waitOutOfLevel>5__3;
<>1__state = 2;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static readonly Color OffColor;
public static readonly Color TargetBothColor;
public static readonly Color TargetPlayerOnlyColor;
public static readonly Color TargetEnemyOnlyColor;
public static readonly Color DoesNotTargetColor;
public const string PUBLIC_NAME_PREFIX = "E0$L$$";
private const float SYNC_ALL_IN = 15f;
private static Coroutine s_syncLSSAmmoCoroutine;
private LSSTargeted m_LSSTargeted = new LSSTargeted();
public const string LSS_SYNC_EVT = "LSS_SYNC_EVT";
public LevelSpawnedSentryDefinition Def { get; }
public int InstanceIndex { get; }
public LSSSyncState State => StateReplicator?.State ?? default(LSSSyncState);
internal StateReplicator<LSSSyncState> StateReplicator { get; private set; }
public LSSComp LSSComp { get; private set; }
public int LastSyncedTargetedPlayer => m_LSSTargeted.PlayerSlotIndex;
public static Color GetScanningColor(bool targetEnemy, bool targetPlayer)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: 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_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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)
Color val = Color.grey * 0.5f;
if (targetEnemy && targetPlayer)
{
return TargetBothColor;
}
if (targetEnemy && !targetPlayer)
{
return TargetEnemyOnlyColor;
}
if (!targetEnemy && targetPlayer)
{
return TargetPlayerOnlyColor;
}
return DoesNotTargetColor;
}
public static string GetMarkerText(bool targetEnemy, bool targetPlayer)
{
string empty = string.Empty;
string empty2 = string.Empty;
if (targetEnemy && targetPlayer)
{
empty = "LSS.State.Both";
empty2 = "HAVOC";
}
else if (targetEnemy && !targetPlayer)
{
empty = "LSS.State.Normal";
empty2 = "NORMAL";
}
else if (!targetEnemy && targetPlayer)
{
empty = "LSS.State.Player";
empty2 = "HOSTILE";
}
else
{
empty = "LSS.State.Idle";
empty2 = "IDLE";
}
TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock(empty);
if (block == null)
{
return empty2;
}
return Text.Get(((GameDataBlockBase<TextDataBlock>)(object)block).persistentID);
}
internal void AssignInstance(LSSComp comp)
{
if (!comp.IsSetup)
{
EOSLogger.Error("LSS: Assigning to LSS '" + comp.Def.WorldEventObjectFilter + "' an un-setup LSSComp!");
return;
}
bool num = (Object)(object)LSSComp != (Object)null;
if (num)
{
EOSLogger.Warning("LSS: re-assigning LSSComp to '" + comp.Def.WorldEventObjectFilter + "'!");
}
LSSComp = comp;
if (num)
{
OnStateChanged(State, State, isRecall: false);
}
}
internal void SetupReplicator()
{
if (StateReplicator != null)
{
return;
}
LevelSpawnedSentryDefinition def = Def;
uint num = EOSNetworking.AllotReplicatorID();
if (num != 0)
{
LSSSyncState lSSSyncState = new LSSSyncState(def.InitialState);
lSSSyncState.Ammo = def.InitialAmmo;
LSSSyncState lSSSyncState2 = lSSSyncState;
StateReplicator = StateReplicator<LSSSyncState>.Create(num, lSSSyncState2, (LifeTimeType)1, (IStateReplicatorHolder<LSSSyncState>)null);
StateReplicator.OnStateChanged += OnStateChanged;
if (SNet.IsMaster)
{
StateReplicator.SetState(lSSSyncState2);
}
}
}
private void OnStateChanged(LSSSyncState oldState, LSSSyncState newState, bool isRecall)
{
if (isRecall)
{
EOSLogger.Warning("LSS.OnStateChanged recall! Gonna re-assign LSSComp!");
SpawnLSS_OnRecall();
}
else if ((Object)(object)LSSComp == (Object)null)
{
EOSLogger.Error("LSS.OnStateChanged: LSSComp is null!");
}
else
{
LSSComp.OnStateChanged(oldState, newState, isRecall);
}
}
internal void Destroy()
{
EOSLogger.Error("LSS Destroyed: " + Def.WorldEventObjectFilter);
LevelAPI.OnBuildDone -= SetupReplicator;
LevelAPI.OnEnterLevel -= SpawnLSS_OnEnterLevel;
StateReplicator?.Unload();
StateReplicator = null;
}
private void SpawnLSS_OnEnterLevel()
{
SpawnLSS(Def.InitialAmmo);
}
private void SpawnLSS_OnRecall()
{
SpawnLSS(State.Ammo);
}
private void SpawnLSS(float ammo)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: 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_00bf: Expected O, but got Unknown
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Unknown result type (might be due to invalid IL or missing references)
if (!SNet.IsMaster)
{
return;
}
LevelSpawnedSentryDefinition def = Def;
Vector3 val = def.Position.ToVector3();
AIG_GeomorphNodeVolume val2 = default(AIG_GeomorphNodeVolume);
AIG_VoxelNodePillar val3 = default(AIG_VoxelNodePillar);
AIG_INode val4 = default(AIG_INode);
AIG_NodeCluster val5 = default(AIG_NodeCluster);
if (!AIG_GeomorphNodeVolume.TryGetGeomorphVolume(0, def.DimensionIndex, val, ref val2) || !((AIG_NodeVolume)val2).m_voxelNodeVolume.TryGetPillar(val, ref val3) || !val3.TryGetVoxelNode(val.y, ref val4) || !AIG_NodeCluster.TryGetNodeCluster(val4.ClusterID, ref val5))
{
EOSLogger.Error("SpawnLSS: Position is not valid, try again inside an area.");
return;
}
AIG_CourseNode courseNode = val5.CourseNode;
PlayerOfflineGearDataBlock block = GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(def.PlayerOfflineGearDBId);
if (block == null)
{
EOSLogger.Error($"SpawnLSS: missing PlayerOfflineGearDataBlock with Id {def.PlayerOfflineGearDBId}");
return;
}
GearIDRange val6 = new GearIDRange(block.GearJSON);
val6.PublicGearName = $"{"E0$L$$"}_{InstanceIndex}";
val6.PlayfabItemId = ((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)block).name;
val6.PlayfabItemInstanceId = $"OfflineGear_LSS_ID_{((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)block).persistentID}";
val6.OfflineGearType = (eOfflineGearType)3;
if (val6.GetCompID((eGearComponent)3) != 0)
{
GameDataBlockBase<ItemDataBlock>.GetBlock(val6.GetCompID((eGearComponent)3));
}
ItemReplicationManager.SpawnGear(val6, (delItemCallback)null, (ItemMode)3, val, def.Rotation.ToQuaternion(), courseNode, (PlayerAgent)null, ammo, Def.AmmoCap);
}
private LSS(LevelSpawnedSentryDefinition def, int instanceIndex)
{
Def = def;
InstanceIndex = instanceIndex;
}
internal static LSS Instantiate(LevelSpawnedSentryDefinition def, int instanceIndex)
{
LSS lSS = new LSS(def, instanceIndex);
LevelAPI.OnBuildDone += lSS.SetupReplicator;
LevelAPI.OnEnterLevel += lSS.SpawnLSS_OnEnterLevel;
return lSS;
}
[IteratorStateMachine(typeof(<s_sync>d__35))]
private static IEnumerator s_sync()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <s_sync>d__35(0);
}
static LSS()
{
//IL_0005: 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_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_0023: 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_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
OffColor = ColorExt.Hex("#00000000");
TargetBothColor = ColorExt.Hex("FFFA00");
TargetPlayerOnlyColor = ColorExt.Hex("#F0192EFF");
TargetEnemyOnlyColor = ColorExt.Hex("#00895CFF");
DoesNotTargetColor = ColorExt.Hex("#198AF0FF") * 0.5f;
s_syncLSSAmmoCoroutine = null;
SetupSync();
s_syncLSSAmmoCoroutine = CoroutineManager.StartPersistantCoroutine(CollectionExtensions.WrapToIl2Cpp(s_sync()));
EOSLogger.Debug("===========================");
EOSLogger.Debug("LSS Sync coroutine started");
EOSLogger.Debug("===========================");
}
internal void OnTargetedPlayer(PlayerAgent player)
{
m_LSSTargeted.PlayerSlotIndex = ((player != null) ? player.Owner.PlayerSlotIndex() : (-1));
}
internal void OnUpdateMaster()
{
m_LSSTargeted.LSSInstanceIndex = InstanceIndex;
NetworkAPI.InvokeEvent<LSSTargeted>("LSS_SYNC_EVT", m_LSSTargeted, (SNet_ChannelType)2);
}
private static void OnReceive(ulong sender, LSSTargeted data)
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
int lSSInstanceIndex = data.LSSInstanceIndex;
if (lSSInstanceIndex < 0 || lSSInstanceIndex >= LevelSpawnedSentryManager.Current.LSSInstances.Count)
{
EOSLogger.Error($"LSS_OnReceive: got packet with invalid instance index {lSSInstanceIndex}, LSSCount: {LevelSpawnedSentryManager.Current.LSSInstances.Count}, CurrentGameState: {GameStateManager.CurrentStateName}");
}
else
{
LevelSpawnedSentryManager.Current.LSSInstances[lSSInstanceIndex].m_LSSTargeted.PlayerSlotIndex = data.PlayerSlotIndex;
EOSLogger.Warning($"LSSSync.OnReceive: LSS_{lSSInstanceIndex}, Player_{data.PlayerSlotIndex}");
}
}
private static void SetupSync()
{
NetworkAPI.RegisterEvent<LSSTargeted>("LSS_SYNC_EVT", (Action<ulong, LSSTargeted>)OnReceive);
EOSLogger.Debug("===========================");
EOSLogger.Debug("LSSTargeted Sync EVT Registered");
EOSLogger.Debug("===========================");
}
}
[HarmonyPatch]
public static class LSSDebug
{
}
}
namespace EOSExt.LevelSpawnedSentry.PlayerGUIMessage
{
public class PlayerGUIMessageManager
{
private PUI_ObjectiveTimer m_timerLayer;
private ISet<int> m_targetedByLSS = new HashSet<int>();
public static PlayerGUIMessageManager Current { get; }
public static PlayerGuiLayer PlayerGUILayer => GuiManager.PlayerLayer;
internal void Setup(Transform root)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
m_timerLayer = ((Il2CppObjectBase)((GuiLayer)PlayerGUILayer).AddComp("Gui/Player/PUI_ObjectiveTimer", (GuiAnchor)0, new Vector2(0f, -200f), (Transform)null)).Cast<PUI_ObjectiveTimer>();
}
internal void OnLocalPlayerTargeted(LSS sentry)
{
m_targetedByLSS.Add(sentry.InstanceIndex);
if (m_targetedByLSS.Count > 0 && !((Component)m_timerLayer).gameObject.active)
{
TextDataBlock block = GameDataBlockBase<TextDataBlock>.GetBlock("LSS.OnPlayerTargeted.GUIText");
SetText((block != null) ? Text.Get(((GameDataBlockBase<TextDataBlock>)(object)block).persistentID) : "<color=red>OMG IM SO FKING DEAD</color>");
}
}
internal void OnLocalPlayerUnTargeted(LSS sentry)
{
m_targetedByLSS.Remove(sentry.InstanceIndex);
if (m_targetedByLSS.Count == 0)
{
Clear();
}
}
public void SetText(string text)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Invalid comparison between Unknown and I4
((Component)m_timerLayer).gameObject.active = true;
m_timerLayer.UpdateTimerTitle(text);
if ((int)GameStateManager.CurrentStateName == 10)
{
CoroutineManager.BlinkIn(((Component)m_timerLayer.m_titleText).gameObject, 0f);
}
}
public void Clear()
{
((Component)m_timerLayer).gameObject.active = false;
m_timerLayer.SetTimerTextEnabled(false);
}
private void OnLevelCleanup()
{
Clear();
m_targetedByLSS.Clear();
}
private PlayerGUIMessageManager()
{
LevelAPI.OnBuildStart += OnLevelCleanup;
LevelAPI.OnLevelCleanup += OnLevelCleanup;
}
static PlayerGUIMessageManager()
{
Current = new PlayerGUIMessageManager();
}
}
}
namespace EOSExt.LevelSpawnedSentry.Patches
{
[HarmonyPatch]
internal static class DisableAnalytic
{
[HarmonyPrefix]
[HarmonyPatch(typeof(AnalyticsManager), "SentryEventsPayload")]
private static bool Pre_(SentryGunInstance __instance)
{
if ((Object)(object)__instance != (Object)null)
{
return (Object)(object)((Item)__instance).Owner != (Object)null;
}
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SentryPlaced), "OnGameEvent")]
private static bool Pre_(GameEventData data)
{
return (Object)(object)data.player != (Object)null;
}
}
[HarmonyPatch]
internal static class DisableWarp
{
[HarmonyPrefix]
[HarmonyPatch(typeof(SentryGunInstance), "OnWarp")]
private static bool Pre_(SentryGunInstance __instance)
{
return (Object)(object)((Component)__instance).gameObject.GetComponent<LSSComp>() == (Object)null;
}
}
[HarmonyPatch]
internal static class Firing
{
[HarmonyPrefix]
[HarmonyWrapSafe]
[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "FireBullet")]
private static bool Pre_FireBullet(SentryGunInstance_Firing_Bullets __instance, bool doDamage, bool targetIsTagged)
{
//IL_003c: 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_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
//IL_020d: Unknown result type (might be due to invalid IL or missing references)
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Unknown result type (might be due to invalid IL or missing references)
//IL_0227: 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_0242: Unknown result type (might be due to invalid IL or missing references)
//IL_024d: Unknown result type (might be due to invalid IL or missing references)
//IL_0257: Unknown result type (might be due to invalid IL or missing references)
//IL_025c: Unknown result type (might be due to invalid IL or missing references)
//IL_0261: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_028d: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Unknown result type (might be due to invalid IL or missing references)
//IL_029c: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
iSentrygunInstanceCore core = __instance.m_core;
SentryGunInstance val = ((core != null) ? ((Il2CppObjectBase)core).TryCast<SentryGunInstance>() : null);
LSSComp lSSComp = ((val != null) ? ((Component)val).gameObject.GetComponent<LSSComp>() : null);
if ((Object)(object)lSSComp == (Object)null)
{
return true;
}
_ = lSSComp.LSS.State;
WeaponHitData val3 = (SentryGunInstance_Firing_Bullets.s_weaponRayData = new WeaponHitData
{
randomSpread = __instance.m_archetypeData.HipFireSpread,
fireDir = __instance.MuzzleAlign.forward
});
Vector3 val4 = default(Vector3);
if (__instance.m_archetypeData.Sentry_FireTowardsTargetInsteadOfForward && __instance.m_core.TryGetTargetAimPos(ref val4))
{
WeaponHitData s_weaponRayData = SentryGunInstance_Firing_Bullets.s_weaponRayData;
Vector3 val5 = val4 - __instance.MuzzleAlign.position;
s_weaponRayData.fireDir = ((Vector3)(ref val5)).normalized;
}
if (Weapon.CastWeaponRay(__instance.MuzzleAlign, ref val3, LayerManager.MASK_SENTRYGUN_RAY))
{
SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = __instance.m_core.Owner;
GameObject target = val.m_detection.Target;
PlayerAgent val6 = ((target != null) ? target.GetComponent<PlayerAgent>() : null);
if (val.m_detection.HasTarget && (Object)(object)val6 != (Object)null)
{
SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = val.m_detection.Target.GetComponent<PlayerAgent>();
}
else
{
SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = LocalPlayer.Agent;
}
SentryGunInstance_Firing_Bullets.s_weaponRayData.damage = (targetIsTagged ? (__instance.m_archetypeData.Damage * __instance.m_archetypeData.Sentry_DamageTagMulti) : __instance.m_archetypeData.Damage);
SentryGunInstance_Firing_Bullets.s_weaponRayData.staggerMulti = __instance.m_archetypeData.GetSentryStaggerDamage(targetIsTagged);
SentryGunInstance_Firing_Bullets.s_weaponRayData.precisionMulti = __instance.m_archetypeData.PrecisionDamageMulti;
SentryGunInstance_Firing_Bullets.s_weaponRayData.damageFalloff = __instance.m_archetypeData.DamageFalloff;
SentryGunInstance_Firing_Bullets.s_weaponRayData.vfxBulletHit = __instance.m_vfxBulletHit;
BulletWeapon.BulletHit(SentryGunInstance_Firing_Bullets.s_weaponRayData, doDamage, 0f, 0u, true);
RaycastHit rayHit = SentryGunInstance_Firing_Bullets.s_weaponRayData.rayHit;
FX_Manager.EffectTargetPosition = ((RaycastHit)(ref rayHit)).point;
Vector3 position = __instance.MuzzleAlign.position;
rayHit = SentryGunInstance_Firing_Bullets.s_weaponRayData.rayHit;
Debug.DrawLine(position, ((RaycastHit)(ref rayHit)).point, Color.yellow);
}
else
{
FX_Manager.EffectTargetPosition = __instance.MuzzleAlign.position + __instance.MuzzleAlign.forward * 50f;
Debug.DrawLine(__instance.MuzzleAlign.position, __instance.MuzzleAlign.position + __instance.MuzzleAlign.forward * 10f, Color.green);
}
Action onBulletFired = __instance.OnBulletFired;
if (onBulletFired != null)
{
onBulletFired.Invoke();
}
((FX_EffectBase)SentryGunInstance_Firing_Bullets.s_tracerPool.AquireEffect()).Play((FX_Trigger)null, __instance.MuzzleAlign.position, Quaternion.LookRotation(SentryGunInstance_Firing_Bullets.s_weaponRayData.fireDir));
EX_SpriteMuzzleFlash muzzleFlash = __instance.m_muzzleFlash;
if ((Object)(object)muzzleFlash != (Object)null)
{
muzzleFlash.Play();
}
WeaponShellManager.EjectShell((ShellTypes)3, 1f, (float)Random.RandomRangeInt(3, 5), __instance.ShellEjectAlign);
__instance.m_fireBulletTimer = Clock.Time + __instance.m_archetypeData.GetSentryShotDelay(__instance.m_core.Owner, targetIsTagged);
return false;
}
[HarmonyPrefix]
[HarmonyWrapSafe]
[HarmonyPatch(typeof(SentryGunInstance_Firing_Bullets), "UpdateFireShotgunSemi")]
private static bool Pre_UpdateFireShotgunSemi(SentryGunInstance_Firing_Bullets __instance, bool isMaster, bool targetIsTagged)
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_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_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00e7: 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_00fa: Expected O, but got Unknown
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_022d: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
//IL_0242: Unknown result type (might be due to invalid IL or missing references)
//IL_0247: Unknown result type (might be due to invalid IL or missing references)
//IL_0268: Unknown result type (might be due to invalid IL or missing references)
//IL_0272: Unknown result type (might be due to invalid IL or missing references)
//IL_0277: Unknown result type (might be due to invalid IL or missing references)
//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
//IL_0217: Unknown result type (might be due to invalid IL or missing references)
//IL_021b: Unknown result type (might be due to invalid IL or missing references)
iSentrygunInstanceCore core = __instance.m_core;
SentryGunInstance val = ((core != null) ? ((Il2CppObjectBase)core).TryCast<SentryGunInstance>() : null);
LSSComp lSSComp = ((val != null) ? ((Component)val).gameObject.GetComponent<LSSComp>() : null);
if ((Object)(object)lSSComp == (Object)null)
{
return true;
}
_ = lSSComp.LSS.State;
if (Clock.Time > __instance.m_fireBulletTimer)
{
Vector3 position = __instance.MuzzleAlign.position;
__instance.TriggerSingleFireAudio();
for (int i = 0; i < __instance.m_archetypeData.ShotgunBulletCount; i++)
{
float num = __instance.m_segmentSize * (float)i;
float num2 = 0f;
float num3 = 0f;
if (i > 0)
{
num2 += (float)__instance.m_archetypeData.ShotgunConeSize * Mathf.Cos(num);
num3 += (float)__instance.m_archetypeData.ShotgunConeSize * Mathf.Sin(num);
}
WeaponHitData val3 = (SentryGunInstance_Firing_Bullets.s_weaponRayData = new WeaponHitData
{
maxRayDist = __instance.MaxRayDist,
angOffsetX = num2,
angOffsetY = num3,
randomSpread = __instance.m_archetypeData.ShotgunBulletSpread,
fireDir = __instance.MuzzleAlign.forward
});
if (Weapon.CastWeaponRay(__instance.MuzzleAlign, ref val3, position, LayerManager.MASK_SENTRYGUN_RAY))
{
SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = __instance.m_core.Owner;
GameObject target = val.m_detection.Target;
PlayerAgent val4 = ((target != null) ? target.GetComponent<PlayerAgent>() : null);
if (val.m_detection.HasTarget && (Object)(object)val4 != (Object)null)
{
SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = val.m_detection.Target.GetComponent<PlayerAgent>();
}
else
{
SentryGunInstance_Firing_Bullets.s_weaponRayData.owner = LocalPlayer.Agent;
}
SentryGunInstance_Firing_Bullets.s_weaponRayData.damage = (targetIsTagged ? (__instance.m_archetypeData.Damage * __instance.m_archetypeData.Sentry_DamageTagMulti) : __instance.m_archetypeData.Damage);
SentryGunInstance_Firing_Bullets.s_weaponRayData.staggerMulti = __instance.m_archetypeData.GetSentryStaggerDamage(targetIsTagged);
SentryGunInstance_Firing_Bullets.s_weaponRayData.precisionMulti = __instance.m_archetypeData.PrecisionDamageMulti;
SentryGunInstance_Firing_Bullets.s_weaponRayData.damageFalloff = __instance.m_archetypeData.DamageFalloff;
BulletWeapon.BulletHit(SentryGunInstance_Firing_Bullets.s_weaponRayData, isMaster, 0f, 0u, true);
RaycastHit rayHit = SentryGunInstance_Firing_Bullets.s_weaponRayData.rayHit;
FX_Manager.EffectTargetPosition = ((RaycastHit)(ref rayHit)).point;
}
else
{
FX_Manager.EffectTargetPosition = __instance.MuzzleAlign.position + __instance.MuzzleAlign.forward * 50f;
}
FX_Manager.PlayLocalVersion = false;
((FX_EffectBase)SentryGunInstance_Firing_Bullets.s_tracerPool.AquireEffect()).Play((FX_Trigger)null, __instance.MuzzleAlign.position, Quaternion.LookRotation(SentryGunInstance_Firing_Bullets.s_weaponRayData.fireDir));
}
__instance.UpdateAmmo(-1);
Action onBulletFired = __instance.OnBulletFired;
if (onBulletFired != null)
{
onBulletFired.Invoke();
}
__instance.m_fireBulletTimer = Clock.Time + (targetIsTagged ? (__instance.m_archetypeData.ShotDelay * __instance.m_archetypeData.Sentry_ShotDelayTagMulti) : __instance.m_archetypeData.ShotDelay);
}
return false;
}
}
[HarmonyPatch]
internal static class OnLSSSpawned
{
[HarmonyPostfix]
[HarmonyPatch(typeof(SentryGunInstance), "OnSpawn")]
private static void Post_(SentryGunInstance __instance, pGearSpawnData spawnData)
{
string data = spawnData.gearIDRange.publicName.data;
if (data.StartsWith("E0$L$$"))
{
List<LSS> lSSInstances = LevelSpawnedSentryManager.Current.LSSInstances;
if (!int.TryParse(data.Split('_')[1], out var result) || result < 0 || result >= lSSInstances.Count)
{
EOSLogger.Error("SentryGunInstance.OnSpawn: got publicName '" + data + "' with in valid instanceIndex");
return;
}
LSS lSS = lSSInstances[result];
LevelSpawnedSentryManager.Current.LSSInstances[result].AssignInstance(((Component)__instance).gameObject.AddComponent<LSSComp>().Setup(lSS));
((Behaviour)((Il2CppObjectBase)((Item)__instance).PickupInteraction).Cast<Interact_Timed>()).enabled = false;
Dimension.RemoveWarpable(((Il2CppObjectBase)__instance).Cast<IWarpableObject>());
EOSLogger.Warning("LSS OnSpawn: " + lSS.Def.WorldEventObjectFilter);
}
}
}
[HarmonyPatch]
internal static class OnSetup
{
[HarmonyPostfix]
[HarmonyPatch(typeof(SentryGunInstance), "CheckIsSetup")]
private static void Post_CheckSetup(SentryGunInstance __instance)
{
LSSComp component = ((Component)__instance).gameObject.GetComponent<LSSComp>();
if ((Object)(object)component != (Object)null)
{
EOSLogger.Warning("LSS CheckSetup: " + component.Def.WorldEventObjectFilter);
component.UpdateVisuals();
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(SentryGunInstance_Detection), "Setup")]
private static void Post_D_Setup(SentryGunInstance_Detection __instance)
{
SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
if (!((Object)(object)lSSComp == (Object)null))
{
__instance.m_targetPlayers = lSSComp.LSS.State.TargetPlayer;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(SentryGunInstance_ScannerVisuals_Plane), "Setup")]
private static void Post_V_Setup(SentryGunInstance_ScannerVisuals_Plane __instance)
{
if ((Object)(object)__instance.m_scannerPlane == (Object)null || (Object)(object)__instance.m_targetingAlign == (Object)null)
{
EOSLogger.Error("SentryGunInstance_ScannerVisuals_Plane.Setup: got a null scannerPlane / targetingAlign?");
}
SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
if (!((Object)(object)lSSComp == (Object)null))
{
lSSComp.UpdateVisuals();
}
}
}
[HarmonyPatch]
internal static class OnPlayerGuiLayerSetup
{
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerGuiLayer), "Setup")]
private static void Post_(PlayerGuiLayer __instance, Transform root, string name)
{
PlayerGUIMessageManager.Current.Setup(root);
}
}
[HarmonyPatch]
internal static class ReceiveToolRefill
{
}
[HarmonyPatch]
[HarmonyPatch]
[HarmonyPatch]
internal static class Targeting
{
[HarmonyPrefix]
[HarmonyWrapSafe]
[HarmonyPatch(typeof(SentryGunInstance_Sync), "UpdateMaster")]
private static void Post_UpdateMaster(SentryGunInstance_Sync __instance)
{
if (!(Clock.Time - __instance.m_lastSyncTime <= 0.5f))
{
SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
if (!((Object)(object)lSSComp == (Object)null))
{
lSSComp.LSS.OnUpdateMaster();
}
}
}
[HarmonyPrefix]
[HarmonyWrapSafe]
[HarmonyPatch(typeof(SentryGunInstance_Sync), "UpdateClient")]
private static void Post_UpdateClient(SentryGunInstance_Sync __instance)
{
if (Clock.Time - __instance.m_lastSyncTime > __instance.m_syncTimeout)
{
SentryGunInstance obj = ((Il2CppObjectBase)__instance.m_core).TryCast<SentryGunInstance>();
LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
if (!((Object)(object)lSSComp == (Object)null))
{
lSSComp.LSS.OnTargetedPlayer(null);
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(SentryGunInstance), "UpdateMaster")]
private static void Post_UpdateMaster(SentryGunInstance __instance)
{
LSSComp lSSComp = ((__instance != null) ? ((Component)__instance).gameObject.GetComponent<LSSComp>() : null);
if ((Object)(object)lSSComp == (Object)null)
{
return;
}
if (!lSSComp.LSS.State.Enabled || !lSSComp.LSS.State.TargetPlayer || !__instance.m_detection.HasTarget || (Object)(object)__instance.m_detection.Target == (Object)null)
{
PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
lSSComp.LSS.OnTargetedPlayer(null);
return;
}
PlayerAgent component = __instance.m_detection.Target.GetComponent<PlayerAgent>();
if ((Object)(object)component == (Object)null || lSSComp.AmmoDepleted)
{
PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
lSSComp.LSS.OnTargetedPlayer(null);
return;
}
if (((Agent)component).IsLocallyOwned)
{
PlayerGUIMessageManager.Current.OnLocalPlayerTargeted(lSSComp.LSS);
}
else
{
PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
}
lSSComp.LSS.OnTargetedPlayer(component);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(SentryGunInstance), "UpdateClient")]
private static void Post_UpdateClient(SentryGunInstance __instance)
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
LSSComp lSSComp = ((__instance != null) ? ((Component)__instance).gameObject.GetComponent<LSSComp>() : null);
if (!((Object)(object)lSSComp == (Object)null))
{
LocalPlayerAgent val = default(LocalPlayerAgent);
if (!lSSComp.LSS.State.Enabled || !lSSComp.LSS.State.TargetPlayer || !__instance.m_sync.LastSyncData.hasTarget)
{
PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
}
else if (!LocalPlayer.TryGetLocalAgent(ref val))
{
EOSLogger.Error("Post_UpdateClient: Cannot get local player agent!");
}
else if (lSSComp.LSS.LastSyncedTargetedPlayer == ((PlayerAgent)val).Owner.PlayerSlotIndex())
{
PlayerGUIMessageManager.Current.OnLocalPlayerTargeted(lSSComp.LSS);
}
else
{
PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
}
}
}
[HarmonyPrefix]
[HarmonyWrapSafe]
[HarmonyPatch(typeof(SentryGunInstance), "WantToScan")]
private static bool Pre_WantToScan(SentryGunInstance __instance, ref bool __result)
{
LSSComp component = ((Component)__instance).gameObject.GetComponent<LSSComp>();
if ((Object)(object)component == (Object)null)
{
return true;
}
if (!component.LSS.State.Enabled)
{
__result = false;
return false;
}
return true;
}
[HarmonyPrefix]
[HarmonyWrapSafe]
[HarmonyPatch(typeof(SentryGunInstance_Detection), "UpdateDetection")]
private static bool Pre_UpdateDetection_OnlyTargetPlayer_Master(SentryGunInstance_Detection __instance)
{
//IL_0091: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
iSentrygunInstanceCore core = __instance.m_core;
SentryGunInstance obj = ((core != null) ? ((Il2CppObjectBase)core).TryCast<SentryGunInstance>() : null);
LSSComp lSSComp = ((obj != null) ? ((Component)obj).gameObject.GetComponent<LSSComp>() : null);
if ((Object)(object)obj == (Object)null || (Object)(object)lSSComp == (Object)null)
{
return true;
}
if (!lSSComp.LSS.State.Enabled)
{
PlayerGUIMessageManager.Current.OnLocalPlayerUnTargeted(lSSComp.LSS);
return false;
}
if (lSSComp.LSS.State.TargetEnemy)
{
return true;
}
if (Clock.Time > __instance.m_scanningTimer)
{
_ = ((Component)__instance.DetectionSource).transform.forward;
Vector3 position = ((Component)__instance.DetectionSource).transform.position;
if (__instance.m_core.Ammo >= __instance.m_core.CostOfBullet)
{
__instance.Target = null;
__instance.TargetAimTrans = null;
__instance.TargetIsTagged = false;
if (__instance.m_targetPlayers)
{
PlayerAgent val = SentryGunInstance_Detection.CheckForPlayerTarget(__instance.m_archetypeData, __instance.DetectionSource, __instance.Target);
if ((Object)(object)val != (Object)null)
{
__instance.Target = ((Component)val).gameObject;
__instance.TargetAimTrans = ((Agent)val).TentacleTarget;
}
}
}
if ((Object)(object)__instance.Target != (Object)null)
{
Vector3 position2 = __instance.Target.transform.position;
if (!__instance.HasTarget)
{
__instance.HasTarget = true;
Action onFoundTarget = __instance.OnFoundTarget;
if (onFoundTarget != null)
{
onFoundTarget.Invoke();
}
}
Debug.DrawLine(position, position2);
}
else
{
__instance.HasTarget = false;
__instance.TargetIsTagged = false;
}
}
return false;
}
}
}
namespace EOSExt.LevelSpawnedSentry.Impl
{
public class LSSComp : MonoBehaviour
{
public LSS LSS { get; private set; }
public LevelSpawnedSentryDefinition Def => LSS.Def;
public SentryGunInstance_ScannerVisuals_Plane Visuals => ((Component)this).gameObject.GetComponent<SentryGunInstance_ScannerVisuals_Plane>();
public SentryGunInstance Sentry => ((Component)this).gameObject.GetComponent<SentryGunInstance>();
public NavMarker marker { get; private set; }
public bool IsSetup => LSS != null;
public bool AmmoDepleted
{
get
{
if (Sentry.Ammo < Sentry.CostOfBullet)
{
return !Sentry.m_ammoDepleatedWarning;
}
return false;
}
}
internal LSSComp Setup(LSS lss)
{
//IL_0053: 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_006b: Unknown result type (might be due to invalid IL or missing references)
if (!IsSetup)
{
LSS = lss;
LevelSpawnedSentryDefinition def = Def;
marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(((Component)this).gameObject);
if ((Object)(object)marker != (Object)null)
{
Color scanningColor = LSS.GetScanningColor(def.InitialState.TargetEnemy, def.InitialState.TargetPlayer);
marker.SetStyle((eNavMarkerStyle)0);
marker.SetColor(scanningColor);
marker.SetVisible(def.InitialState.Enabled);
marker.SetTitle(LSS.GetMarkerText(def.InitialState.TargetEnemy, def.InitialState.TargetPlayer));
}
UpdateVisuals();
SetCanRefill(def.InitialState.CanRefill);
}
return this;
}
public void SetCanRefill(bool canRefill)
{
Sentry.AmmoMaxCap = (canRefill ? Def.AmmoCap : 0f);
}
internal void OnStateChanged(LSSSyncState oldState, LSSSyncState newState, bool isRecall)
{
EOSLogger.Debug($"LSSOnStateChanged \"{Def.WorldEventObjectFilter}\"! OldState: [{oldState}], NewState: {newState}");
SentryGunInstance sentry = Sentry;
if (newState.Enabled)
{
sentry.m_isSetup = true;
sentry.m_isScanning = false;
sentry.m_startScanTimer = Clock.Time + sentry.m_initialScanDelay;
if (!oldState.Enabled)
{
((ItemEquippable)sentry).Sound.Post(EVENTS.SENTRYGUN_LOW_AMMO_WARNING, true);
}
}
else
{
if (sentry.m_isFiring)
{
sentry.StopFiring();
}
if (sentry.m_isScanning)
{
sentry.StopScanning();
}
sentry.m_isSetup = false;
((ItemEquippable)sentry).Sound.Post(EVENTS.SENTRYGUN_STOP_ALL_LOOPS, true);
}
iSentrygunInstance_Detection detection = sentry.m_detection;
SentryGunInstance_Detection val = ((detection != null) ? ((Il2CppObjectBase)detection).TryCast<SentryGunInstance_Detection>() : null);
if ((Object)(object)val != (Object)null)
{
val.m_targetPlayers = newState.TargetPlayer;
}
SetCanRefill(newState.CanRefill);
UpdateVisuals();
}
internal void UpdateVisuals()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
LSSSyncState state = LSS.State;
SentryGunInstance_ScannerVisuals_Plane visuals = Visuals;
Color color = (visuals.m_scanningColor = LSS.GetScanningColor(state.TargetEnemy, state.TargetPlayer));
if (state.Enabled)
{
if (visuals.m_core != null)
{
visuals.SetVisualStatus((eSentryGunStatus)((!AmmoDepleted) ? 1 : 4), true);
}
if (state.MarkerVisible)
{
NavMarker obj = marker;
if (obj != null)
{
obj.SetColor(color);
}
NavMarker obj2 = marker;
if (obj2 != null)
{
obj2.SetVisible(true);
}
NavMarker obj3 = marker;
if (obj3 != null)
{
obj3.SetTitle(LSS.GetMarkerText(state.TargetEnemy, state.TargetPlayer));
}
}
else
{
NavMarker obj4 = marker;
if (obj4 != null)
{
obj4.SetVisible(false);
}
}
}
else
{
if (visuals.m_core != null)
{
visuals.m_scannerPlane.SetColor(LSS.OffColor);
visuals.UpdateLightProps(LSS.OffColor, false);
}
NavMarker obj5 = marker;
if (obj5 != null)
{
obj5.SetVisible(false);
}
}
}
private void OnDestroy()
{
GuiManager.NavMarkerLayer.RemoveMarker(marker);
marker = null;
}
static LSSComp()
{
ClassInjector.RegisterTypeInIl2Cpp<LSSComp>();
}
}
public struct LSSTargeted
{
public int LSSInstanceIndex { get; set; }
public int PlayerSlotIndex { get; set; }
public LSSTargeted()
{
LSSInstanceIndex = -1;
PlayerSlotIndex = -1;
}
public LSSTargeted(LSSTargeted o)
{
LSSInstanceIndex = -1;
PlayerSlotIndex = -1;
LSSInstanceIndex = o.LSSInstanceIndex;
PlayerSlotIndex = o.PlayerSlotIndex;
}
}
}
namespace EOSExt.LevelSpawnedSentry.Definition
{
public class LevelSpawnedSentryDefinition
{
public string WorldEventObjectFilter { get; set; } = string.Empty;
public uint PlayerOfflineGearDBId { get; set; }
public eDimensionIndex DimensionIndex { get; set; }
public Vec3 Position { get; set; } = new Vec3();
public Vec3 Rotation { get; set; } = new Vec3();
public LSSState InitialState { get; set; } = new LSSState();
public float InitialAmmo { get; set; } = 0.5f;
public float AmmoCap { get; set; } = 1f;
}
public class LSSState
{
public bool Enabled { get; set; } = true;
public bool TargetEnemy { get; set; } = true;
public bool TargetPlayer { get; set; }
public bool MarkerVisible { get; set; } = true;
public bool CanRefill { get; set; } = true;
public LSSState()
{
}
public LSSState(LSSSyncState o)
{
Enabled = o.Enabled;
TargetEnemy = o.TargetEnemy;
TargetPlayer = o.TargetPlayer;
MarkerVisible = o.MarkerVisible;
CanRefill = o.CanRefill;
}
public LSSState(LSSState o)
{
Enabled = o.Enabled;
TargetEnemy = o.TargetEnemy;
TargetPlayer = o.TargetPlayer;
MarkerVisible = o.MarkerVisible;
CanRefill = o.CanRefill;
}
public override string ToString()
{
return $"Enabled: {Enabled}, TargetEnemy/Player: {TargetEnemy}/{TargetPlayer}, CanRefill: {CanRefill}";
}
}
public struct LSSSyncState
{
public bool Enabled { get; set; }
public bool TargetEnemy { get; set; }
public bool TargetPlayer { get; set; }
public bool MarkerVisible { get; set; }
public bool CanRefill { get; set; }
public float Ammo { get; set; }
public LSSSyncState()
{
Enabled = true;
TargetEnemy = true;
TargetPlayer = false;
MarkerVisible = true;
CanRefill = true;
Ammo = 0.5f;
}
public LSSSyncState(LSSSyncState o)
{
Enabled = true;
TargetEnemy = true;
TargetPlayer = false;
MarkerVisible = true;
CanRefill = true;
Ammo = 0.5f;
Enabled = o.Enabled;
TargetEnemy = o.TargetEnemy;
TargetPlayer = o.TargetPlayer;
MarkerVisible = o.MarkerVisible;
CanRefill = o.CanRefill;
Ammo = o.Ammo;
}
public LSSSyncState(LSSState o)
{
Enabled = true;
TargetEnemy = true;
TargetPlayer = false;
MarkerVisible = true;
CanRefill = true;
Ammo = 0.5f;
Enabled = o.Enabled;
TargetEnemy = o.TargetEnemy;
TargetPlayer = o.TargetPlayer;
MarkerVisible = o.MarkerVisible;
CanRefill = o.CanRefill;
}
public override string ToString()
{
return $"Enabled: {Enabled}, TargetEnemy/Player: {TargetEnemy}/{TargetPlayer}, CanRefill: {CanRefill}";
}
}
}