using System;
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 Agents;
using CullingSystem;
using GameData;
using Hikaria.Core;
using Hikaria.Core.Interfaces;
using Hikaria.DropItem.Handlers;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Localization;
using Player;
using SNetwork;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.FeaturesAPI.Settings;
using TheArchive.Core.Localization;
using TheArchive.Interfaces;
using TheArchive.Loader;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyProduct("Hikaria.DropItem")]
[assembly: AssemblyTitle("DropItem")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Hikaria.DropItem
{
[ArchiveDependency(/*Could not decode attribute arguments.*/)]
[ArchiveModule("Hikaria.DropItem", "DropItem", "1.0.0")]
public class EntryPoint : IArchiveModule
{
public bool ApplyHarmonyPatches => false;
public bool UsesLegacyPatches => false;
public ArchiveLegacyPatcher Patcher { get; set; }
public string ModuleGroup => FeatureGroup.op_Implicit(FeatureGroups.GetOrCreateModuleGroup("Drop Item", new Dictionary<Language, string>
{
{
(Language)0,
"Drop Item"
},
{
(Language)1,
"放置物品"
}
}));
public void Init()
{
Logs.LogMessage("OK");
}
public void OnExit()
{
}
public void OnLateUpdate()
{
}
public void OnSceneWasLoaded(int buildIndex, string sceneName)
{
}
}
internal static class Logs
{
private static IArchiveLogger _logger;
private static IArchiveLogger Logger => _logger ?? (_logger = LoaderWrapper.CreateLoggerInstance("Hikaria.DropItem", ConsoleColor.White));
public static void LogDebug(object data)
{
Logger.Debug(data.ToString());
}
public static void LogError(object data)
{
Logger.Error(data.ToString());
}
public static void LogInfo(object data)
{
Logger.Info(data.ToString());
}
public static void LogMessage(object data)
{
Logger.Msg(ConsoleColor.White, data.ToString());
}
public static void LogWarning(object data)
{
Logger.Warning(data.ToString());
}
public static void LogNotice(object data)
{
Logger.Notice(data.ToString());
}
public static void LogSuccess(object data)
{
Logger.Success(data.ToString());
}
public static void LogException(Exception ex)
{
Logger.Exception(ex);
}
}
public static class PluginInfo
{
public const string GUID = "Hikaria.DropItem";
public const string NAME = "DropItem";
public const string VERSION = "1.0.0";
}
}
namespace Hikaria.DropItem.Features
{
[EnableFeatureByDefault]
[DisallowInGameToggle]
[HideInModSettings]
public class DropItem : Feature, IOnRecallComplete
{
[ArchivePatch(/*Could not decode attribute arguments.*/)]
private class PlayerInventoryLocal__DoWieldItem__Patch
{
private static void Postfix(PlayerInventoryLocal __instance)
{
if (((PlayerInventoryBase)__instance).AllowedToWieldItem && DropItemManager.IsInteractDropItem && DropItemManager.CurrentSelectedSlot.IsValidItemForDrop(((PlayerInventoryBase)__instance).WieldedItem))
{
DropItemManager.SpawnItemGhost(DropItemManager.CurrentSelectedSlot, ((PlayerInventoryBase)__instance).Owner);
InteractionGuiLayer interactionLayer = GuiManager.InteractionLayer;
string format = Text.Get(864u);
ItemEquippable wieldedItem = ((PlayerInventoryBase)__instance).WieldedItem;
interactionLayer.SetInteractPrompt(string.Format(format, (wieldedItem != null) ? ((Item)wieldedItem).PublicName : null), string.Format(Text.Get(827u), InputMapper.GetBindingName((InputAction)6)), (ePUIMessageStyle)0);
}
}
}
[ArchivePatch(/*Could not decode attribute arguments.*/)]
private class LG_WeakResourceContainer__Setup__Patch
{
private static void Postfix(LG_WeakResourceContainer __instance)
{
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: 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)
iResourceContainerStorage storage = __instance.m_storage;
LG_ResourceContainer_Storage val = ((storage != null) ? ((Il2CppObjectBase)storage).TryCast<LG_ResourceContainer_Storage>() : null);
if ((Object)(object)val == (Object)null)
{
return;
}
iResourceContainerSync sync = __instance.m_sync;
LG_ResourceContainer_Sync val2 = ((sync != null) ? ((Il2CppObjectBase)sync).TryCast<LG_ResourceContainer_Sync>() : null);
if ((Object)(object)val2 == (Object)null)
{
return;
}
int num = 0;
foreach (StorageSlot item in (Il2CppArrayBase<StorageSlot>)(object)val.m_storageSlots)
{
GameObject val3 = new GameObject($"ResourceContainerSlot_{num}")
{
layer = LayerManager.LAYER_INTERACTION
};
val3.transform.SetParent(((Component)__instance).transform);
val3.AddComponent<LG_WeakResourceContainer_Slot>().Setup(__instance, val2, item, num);
num++;
}
}
}
[ArchivePatch(/*Could not decode attribute arguments.*/)]
private class LG_PickupItem_Sync__Setup__Patch
{
private static void Postfix(LG_PickupItem_Sync __instance)
{
//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_0014: Unknown result type (might be due to invalid IL or missing references)
if ((int)__instance.GetCurrentState().status == 0 && LG_WeakResourceContainer_Slot.TryFindSlot(((Component)__instance).transform.position, out var slot))
{
slot.AddItem(__instance, isSetup: true);
}
}
}
[ArchivePatch(/*Could not decode attribute arguments.*/)]
private class LG_PickupItem_Sync__SetStateFromFactory__Patch
{
private static void Postfix(LG_PickupItem_Sync __instance)
{
//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_0014: Unknown result type (might be due to invalid IL or missing references)
if ((int)__instance.GetCurrentState().status == 0 && LG_WeakResourceContainer_Slot.TryFindSlot(((Component)__instance).transform.position, out var slot))
{
slot.AddItem(__instance, isSetup: true);
}
}
}
[ArchivePatch(/*Could not decode attribute arguments.*/)]
private class LG_PickupItem_Sync__OnStateChange__Patch
{
private static void Prefix(LG_PickupItem_Sync __instance, pPickupItemState newState, bool isRecall)
{
//IL_0000: 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)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Invalid comparison between Unknown and I4
//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)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (newState.updateCustomDataOnly || isRecall)
{
return;
}
LG_WeakResourceContainer_Slot slot2;
if ((int)newState.status == 0)
{
if (LG_WeakResourceContainer_Slot.TryFindSlot(newState.placement.position, out var slot))
{
slot.AddItem(__instance);
ItemInLevel val = ((Il2CppObjectBase)__instance.item).TryCast<ItemInLevel>();
if ((Object)(object)val != (Object)null)
{
val.container = slot.Storage;
}
}
}
else if ((int)newState.status == 1 && LG_WeakResourceContainer_Slot.TryFindSlot(__instance, out slot2))
{
slot2.RemoveItem();
ItemInLevel val2 = ((Il2CppObjectBase)__instance.item).TryCast<ItemInLevel>();
if ((Object)(object)val2 != (Object)null)
{
val2.container = null;
}
}
}
private static void Postfix(LG_PickupItem_Sync __instance, pPickupItemState newState)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
ItemCuller component = ((Component)__instance).GetComponent<ItemCuller>();
if (((component != null) ? ((C_SpecialRenderableObject)component).CullBucket : null) != null)
{
((C_Cullable)((C_SpecialRenderableObject)component).CullBucket).NeedsShadowRefresh = true;
((C_SpecialRenderableObject)component).CullBucket.SetDirtyCMDBuffer();
}
if ((int)newState.status == 0)
{
iTerminalItem componentInChildren = ((Component)__instance.item).GetComponentInChildren<iTerminalItem>();
AIG_CourseNode spawnNode = default(AIG_CourseNode);
if (componentInChildren != null && ((pCourseNode)(ref newState.placement.node)).TryGet(ref spawnNode))
{
componentInChildren.SpawnNode = spawnNode;
}
}
}
}
[ArchivePatch(/*Could not decode attribute arguments.*/)]
private class ItemSpawnManager__SpawnItem__Patch
{
private static void Postfix(Item __result)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
ItemInLevel val = ((__result != null) ? ((Il2CppObjectBase)__result).TryCast<ItemInLevel>() : null);
if ((Object)(object)val == (Object)null || val.CourseNode != null || (int)val.internalSync.GetCurrentState().status != 0)
{
return;
}
pItemData pItemData = ((Item)val).Get_pItemData();
AIG_CourseNode courseNode = default(AIG_CourseNode);
if (((pCourseNode)(ref pItemData.originCourseNode)).TryGet(ref courseNode))
{
val.CourseNode = courseNode;
return;
}
iTerminalItem component = ((Component)val).GetComponent<iTerminalItem>();
if (component != null)
{
val.CourseNode = component.SpawnNode;
return;
}
Transform parent = ((Component)val).transform.parent;
object obj;
if (parent == null)
{
obj = null;
}
else
{
Transform parent2 = parent.parent;
obj = ((parent2 != null) ? ((Component)parent2).GetComponentInChildren<LG_PickupItem>() : null);
}
LG_PickupItem val2 = (LG_PickupItem)obj;
if ((Object)(object)val2 != (Object)null)
{
val.CourseNode = val2.SpawnNode;
}
}
}
[ArchivePatch(/*Could not decode attribute arguments.*/)]
private class LG_ResourceContainer_Storage__SetSpawnNode__Patch
{
private static void Postfix(LG_ResourceContainer_Storage __instance, GameObject obj, AIG_CourseNode spawnNode)
{
//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)
foreach (ItemInLevel componentsInChild in obj.GetComponentsInChildren<ItemInLevel>())
{
if (componentsInChild.CourseNode == null && (int)componentsInChild.internalSync.GetCurrentState().status == 0)
{
componentsInChild.CourseNode = spawnNode;
}
}
}
}
public override string Name => "放置物品";
public override void Init()
{
GameEventAPI.RegisterListener<DropItem>(this);
ClassInjector.RegisterTypeInIl2Cpp<LG_WeakResourceContainer_Slot>(false);
}
public override void OnFeatureSettingChanged(FeatureSetting setting)
{
_ = Feature.CurrentGameState;
_ = 10;
}
public override void OnGameStateChanged(int state)
{
if (state != 10)
{
return;
}
foreach (LG_WeakResourceContainer_Slot item in Object.FindObjectsOfType<LG_WeakResourceContainer_Slot>())
{
item.UpdateInteractionActive();
}
}
public void OnRecallComplete(eBufferType bufferType)
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
if (Feature.CurrentGameState < 10)
{
return;
}
LG_WeakResourceContainer_Slot.RemoveAllItems();
Il2CppArrayBase<LG_WeakResourceContainer_Slot> val = Object.FindObjectsOfType<LG_WeakResourceContainer_Slot>();
foreach (LG_WeakResourceContainer_Slot item in val)
{
item.OnPrepareForRecall();
}
foreach (LG_PickupItem_Sync item2 in Object.FindObjectsOfType<LG_PickupItem_Sync>())
{
if (!((Object)(object)item2.item == (Object)null) && (int)item2.GetCurrentState().status == 0 && LG_WeakResourceContainer_Slot.TryFindSlot(((Component)item2).transform.position, out var slot))
{
slot.AddItem(item2);
}
}
foreach (LG_WeakResourceContainer_Slot item3 in val)
{
item3.UpdateInteractionActive();
}
}
}
}
namespace Hikaria.DropItem.Handlers
{
public static class DropItemManager
{
private static GameObject s_itemGhost;
public static bool IsInteractDropItem { get; private set; }
public static LG_WeakResourceContainer_Slot CurrentSelectedSlot { get; private set; }
public static void OnSelectedChange(LG_WeakResourceContainer_Slot slot, PlayerAgent agent, bool selected)
{
if (selected)
{
CurrentSelectedSlot = slot;
IsInteractDropItem = true;
SpawnItemGhost(slot, agent);
InteractionGuiLayer interactionLayer = GuiManager.InteractionLayer;
string format = Text.Get(864u);
ItemEquippable wieldedItem = agent.Inventory.WieldedItem;
interactionLayer.SetInteractPrompt(string.Format(format, (wieldedItem != null) ? ((Item)wieldedItem).PublicName : null), string.Format(Text.Get(827u), InputMapper.GetBindingName((InputAction)6)), (ePUIMessageStyle)0);
if (agent != null && ((Agent)agent).IsLocallyOwned)
{
agent.Sync.SendGenericInteract((TypeEnum)5, false);
}
}
else
{
CurrentSelectedSlot = null;
IsInteractDropItem = false;
DespawnItemGhost();
}
}
public static void TriggerInteractionAction(LG_WeakResourceContainer_Slot slot, PlayerAgent source)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: 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_00a2: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
PlayerBackpack val = default(PlayerBackpack);
if ((Object)(object)source == (Object)null || !PlayerBackpackManager.TryGetBackpack(source.Owner, ref val))
{
return;
}
ItemEquippable wieldedItem = source.Inventory.WieldedItem;
Item val2 = default(Item);
if ((Object)(object)wieldedItem == (Object)null || !PlayerBackpackManager.TryGetItemInLevelFromItemData(((Item)wieldedItem).Get_pItemData(), ref val2))
{
return;
}
ItemInLevel val3 = ((Il2CppObjectBase)val2).TryCast<ItemInLevel>();
if ((Object)(object)val3 == (Object)null)
{
return;
}
InventorySlot wieldedSlot = source.Inventory.WieldedSlot;
if (slot.TryGetTransform(wieldedSlot, out var transform))
{
iPickupItemSync syncComponent = val3.GetSyncComponent();
if (syncComponent != null)
{
pItemData_Custom customData = syncComponent.GetCustomData();
customData.ammo = val.AmmoStorage.GetInventorySlotAmmo(wieldedSlot).AmmoInPack;
syncComponent.AttemptPickupInteraction((ePickupItemInteractionType)1, source.Owner, customData, transform.position, transform.rotation, slot.SpawnNode, false, false);
}
}
}
public static bool PlayerCanInteract(LG_WeakResourceContainer_Slot slot, PlayerAgent source)
{
if (!slot.IsContainerOpen || slot.IsSlotInUse)
{
return false;
}
return slot.IsValidItemForDrop(source.Inventory.WieldedItem);
}
public static void SpawnItemGhost(LG_WeakResourceContainer_Slot slot, PlayerAgent agent)
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: 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_00e2: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
DespawnItemGhost();
object obj;
if (agent == null)
{
obj = null;
}
else
{
PlayerInventoryBase inventory = agent.Inventory;
obj = ((inventory != null) ? inventory.WieldedItem : null);
}
ItemEquippable val = (ItemEquippable)obj;
if ((Object)(object)val == (Object)null)
{
return;
}
Dictionary<uint, List<GameObject>> val2 = ((Il2CppArrayBase<Dictionary<uint, List<GameObject>>>)(object)ItemSpawnManager.m_loadedPrefabsPerItemMode)[2];
uint itemID_gearCRC = ((Item)val).Get_pItemData().itemID_gearCRC;
if (!val2.ContainsKey(itemID_gearCRC))
{
return;
}
List<GameObject> val3 = val2[itemID_gearCRC];
if (val3 == null || val3.Count < 1)
{
return;
}
GameObject val4 = val3[0];
if ((Object)(object)val4 == (Object)null || !slot.TryGetTransform(agent.Inventory.WieldedSlot, out var transform))
{
return;
}
s_itemGhost = Object.Instantiate<GameObject>(val4, transform.position, transform.rotation);
foreach (Renderer componentsInChild in s_itemGhost.GetComponentsInChildren<Renderer>())
{
foreach (Material item in (Il2CppArrayBase<Material>)(object)componentsInChild.materials)
{
item.shader = Shader.Find("Transparent/Diffuse");
Color black = Color.black;
item.color = ((Color)(ref black)).AlphaMultiplied(0.25f);
}
}
}
public static void DespawnItemGhost()
{
if ((Object)(object)s_itemGhost != (Object)null)
{
Object.Destroy((Object)(object)s_itemGhost);
s_itemGhost = null;
}
}
}
public sealed class LG_WeakResourceContainer_Slot : MonoBehaviour
{
internal class SlotInfo
{
public static readonly SlotInfo[] LockerSlotInfo = new SlotInfo[6]
{
new SlotInfo(new Vector3(-0.724f, -0.252f, 1.754f), new Vector3(0.42f, 0.433f, 0.3f)),
new SlotInfo(new Vector3(-0.672f, -0.252f, 1.454f), new Vector3(0.5f, 0.433f, 0.25f)),
new SlotInfo(new Vector3(-0.672f, -0.252f, 1.154f), new Vector3(0.5f, 0.433f, 0.25f)),
new SlotInfo(new Vector3(-0.672f, -0.252f, 0.854f), new Vector3(0.5f, 0.433f, 0.25f)),
new SlotInfo(new Vector3(-0.672f, -0.252f, 0.354f), new Vector3(0.5f, 0.433f, 0.67f)),
new SlotInfo(new Vector3(-0.276f, -0.252f, 1.754f), new Vector3(0.42f, 0.433f, 0.3f))
};
public static readonly SlotInfo[] BoxSlotInfo = new SlotInfo[3]
{
new SlotInfo(new Vector3(0.009f, 0f, 0.163f), new Vector3(0.33f, 0.54f, 0.323f)),
new SlotInfo(new Vector3(-0.343f, 0f, 0.163f), new Vector3(0.34f, 0.54f, 0.323f)),
new SlotInfo(new Vector3(0.358f, 0f, 0.163f), new Vector3(0.33f, 0.54f, 0.323f))
};
public readonly Vector3 LocalPosition;
public readonly Vector3 LocalScale;
public SlotInfo(Vector3 position, Vector3 scale)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_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)
LocalPosition = position;
LocalScale = scale;
}
}
private static readonly Dictionary<LG_WeakResourceContainer_Slot, int> s_SlotItemLookup = new Dictionary<LG_WeakResourceContainer_Slot, int>();
private static readonly Dictionary<LG_WeakResourceContainer, Dictionary<int, LG_WeakResourceContainer_Slot>> s_ContainerSlotsLookup = new Dictionary<LG_WeakResourceContainer, Dictionary<int, LG_WeakResourceContainer_Slot>>();
private static readonly Dictionary<int, LG_WeakResourceContainer_Slot> s_ItemSlotLookup = new Dictionary<int, LG_WeakResourceContainer_Slot>();
private readonly HashSet<InventorySlot> m_allowedSlots = new HashSet<InventorySlot>();
private LG_WeakResourceContainer m_container;
private LG_ResourceContainer_Storage m_containerStorage;
private LG_WeakResourceContainer_Graphics m_containerGraphics;
private StorageSlot m_slot;
private int m_slotIndex;
private bool m_hasItemInSlot;
private int m_itemInSlot;
private Interact_Timed m_interactionDropItem;
public bool IsContainerOpen
{
get
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Invalid comparison between Unknown and I4
if (!m_container.ISOpen)
{
return (int)m_containerGraphics.m_status == 3;
}
return true;
}
}
public bool IsSlotInUse
{
get
{
if (m_hasItemInSlot)
{
return m_itemInSlot != 0;
}
return false;
}
}
public AIG_CourseNode SpawnNode => m_container.SpawnNode;
public LG_WeakResourceContainer Container => m_container;
public LG_ResourceContainer_Storage Storage => m_containerStorage;
public float InteractDuration
{
get
{
return m_interactionDropItem.InteractDuration;
}
set
{
m_interactionDropItem.InteractDuration = value;
}
}
public void Setup(LG_WeakResourceContainer container, LG_ResourceContainer_Sync sync, StorageSlot slot, int slotIndex)
{
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_0199: 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_0125: 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)
m_container = container;
if (!Object.op_Implicit((Object)(object)m_container))
{
Object.Destroy((Object)(object)this);
return;
}
iResourceContainerGraphics graphics = container.m_graphics;
m_containerGraphics = ((graphics != null) ? ((Il2CppObjectBase)graphics).TryCast<LG_WeakResourceContainer_Graphics>() : null);
if (!Object.op_Implicit((Object)(object)m_containerGraphics))
{
Object.Destroy((Object)(object)this);
return;
}
iResourceContainerStorage storage = container.m_storage;
m_containerStorage = ((storage != null) ? ((Il2CppObjectBase)storage).TryCast<LG_ResourceContainer_Storage>() : null);
if (!s_ContainerSlotsLookup.TryGetValue(m_container, out var value))
{
value = new Dictionary<int, LG_WeakResourceContainer_Slot>();
s_ContainerSlotsLookup[container] = value;
}
value[slotIndex] = this;
m_slot = slot;
m_slotIndex = slotIndex;
if ((Object)(object)slot.ResourcePack != (Object)null)
{
m_allowedSlots.Add((InventorySlot)4);
}
if ((Object)(object)slot.Consumable != (Object)null)
{
m_allowedSlots.Add((InventorySlot)5);
}
if ((Object)(object)slot.Keycard != (Object)null)
{
m_allowedSlots.Add((InventorySlot)7);
}
if (m_container.m_isLocker)
{
SlotInfo slotInfo = SlotInfo.LockerSlotInfo[slotIndex];
((Component)this).gameObject.transform.localRotation = Quaternion.identity;
((Component)this).gameObject.transform.localPosition = slotInfo.LocalPosition;
((Component)this).gameObject.transform.localScale = slotInfo.LocalScale;
((Component)this).gameObject.AddComponent<PlayerPingTarget>().m_pingTargetStyle = (eNavMarkerStyle)10;
}
else
{
SlotInfo slotInfo2 = SlotInfo.BoxSlotInfo[slotIndex];
((Component)this).gameObject.transform.localRotation = Quaternion.identity;
((Component)this).gameObject.transform.localPosition = slotInfo2.LocalPosition;
((Component)this).gameObject.transform.localScale = slotInfo2.LocalScale;
((Component)this).gameObject.AddComponent<PlayerPingTarget>().m_pingTargetStyle = (eNavMarkerStyle)11;
}
m_interactionDropItem = ((Component)this).GetComponent<Interact_Timed>() ?? ((Component)this).gameObject.AddComponent<Interact_Timed>();
m_interactionDropItem.InteractDuration = 0.4f;
m_interactionDropItem.InteractionMessage = string.Empty;
((Interact_Base)m_interactionDropItem).m_colliderToOwn = (Collider)(object)(((Component)this).GetComponent<BoxCollider>() ?? ((Component)this).gameObject.AddComponent<BoxCollider>());
m_interactionDropItem.ExternalPlayerCanInteract = Func<PlayerAgent, bool>.op_Implicit((Func<PlayerAgent, bool>)((PlayerAgent player) => DropItemManager.PlayerCanInteract(this, player)));
m_interactionDropItem.OnInteractionSelected = Action<PlayerAgent, bool>.op_Implicit((Action<PlayerAgent, bool>)delegate(PlayerAgent player, bool state)
{
DropItemManager.OnSelectedChange(this, player, state);
});
m_interactionDropItem.OnInteractionTriggered = Action<PlayerAgent>.op_Implicit((Action<PlayerAgent>)delegate(PlayerAgent player)
{
DropItemManager.TriggerInteractionAction(this, player);
});
((Interact_Base)m_interactionDropItem).OnlyActiveWhenLookingStraightAt = true;
((Interact_Base)m_interactionDropItem).SetActive(true);
sync.OnSyncStateChange += Action<eResourceContainerStatus, bool>.op_Implicit((Action<eResourceContainerStatus, bool>)delegate(eResourceContainerStatus status, bool isRecall)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Invalid comparison between Unknown and I4
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Invalid comparison between Unknown and I4
if ((int)status == 3)
{
((Interact_Base)m_interactionDropItem).SetActive(!IsSlotInUse);
}
else if ((int)status == 2)
{
((Interact_Base)m_interactionDropItem).SetActive(false);
}
});
}
private void OnDestroy()
{
RemoveItem(isDestroy: true);
DropItemManager.DespawnItemGhost();
if (s_ContainerSlotsLookup.TryGetValue(m_container, out var value))
{
value.Remove(m_slotIndex);
if (value.Count < 1)
{
s_ContainerSlotsLookup.Remove(m_container);
}
}
}
public void OnPrepareForRecall()
{
((Interact_Base)m_interactionDropItem).SetActive(true);
}
public void UpdateInteractionActive()
{
((Interact_Base)m_interactionDropItem).SetActive(IsContainerOpen && !IsSlotInUse);
}
public void AddItem(LG_PickupItem_Sync item, bool isSetup = false)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
AddItem(((Object)((Component)item).gameObject).GetInstanceID());
Item item2 = item.item;
ItemInLevel val = ((item2 != null) ? ((Il2CppObjectBase)item2).TryCast<ItemInLevel>() : null);
if (Object.op_Implicit((Object)(object)val))
{
iResourceContainerStorage storage = m_container.m_storage;
LG_ResourceContainer_Storage val2 = ((storage != null) ? ((Il2CppObjectBase)storage).Cast<LG_ResourceContainer_Storage>() : null);
if (Object.op_Implicit((Object)(object)val2))
{
val.container = val2;
}
}
if (!isSetup)
{
InventorySlot slot = (InventorySlot)(((Object)(object)((Il2CppObjectBase)item.item).TryCast<ArtifactPickup_Core>() != (Object)null) ? 7 : ((int)item.item.Get_pItemData().slot));
if (TryGetTransform(slot, out var transform))
{
((Component)item).transform.SetParent(transform);
}
}
}
private void AddItem(int instanceID)
{
if (!IsSlotInUse)
{
m_hasItemInSlot = true;
m_itemInSlot = instanceID;
s_SlotItemLookup[this] = m_itemInSlot;
s_ItemSlotLookup[m_itemInSlot] = this;
((Interact_Base)m_interactionDropItem).SetActive(false);
}
}
public void RemoveItem(bool isDestroy = false)
{
if (IsSlotInUse)
{
m_hasItemInSlot = false;
s_SlotItemLookup.Remove(this);
s_ItemSlotLookup.Remove(m_itemInSlot);
m_itemInSlot = 0;
}
if (!isDestroy)
{
((Interact_Base)m_interactionDropItem).SetActive(IsContainerOpen && !IsSlotInUse);
}
}
public static void RemoveAllItems()
{
foreach (LG_WeakResourceContainer_Slot key in s_SlotItemLookup.Keys)
{
key.RemoveItem();
}
}
public bool TryGetTransform(InventorySlot slot, out Transform transform)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Invalid comparison between Unknown and I4
if (!IsValidInventorySlot(slot))
{
transform = null;
return false;
}
if ((int)slot != 4)
{
if ((int)slot == 5)
{
transform = m_slot.Consumable;
return true;
}
transform = null;
return false;
}
transform = m_slot.ResourcePack;
return true;
}
public static bool TryFindSlot(Vector3 pos, out LG_WeakResourceContainer_Slot slot)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
foreach (Collider item in (Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(pos, 0.01f, LayerManager.MASK_PLAYER_INTERACT_SPHERE))
{
slot = ((Component)item).gameObject.GetComponent<LG_WeakResourceContainer_Slot>();
if ((Object)(object)slot != (Object)null && !slot.IsSlotInUse)
{
return true;
}
}
slot = null;
return false;
}
public static bool TryFindSlot(LG_PickupItem_Sync itemSync, out LG_WeakResourceContainer_Slot slot)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
if (!s_ItemSlotLookup.TryGetValue(((Object)((Component)itemSync).gameObject).GetInstanceID(), out slot) && !TryFindSlot(((Component)itemSync).transform.position, out slot))
{
return false;
}
return true;
}
public bool IsValidItemForDrop(ItemEquippable item)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
InventorySlot? obj;
if (item == null)
{
obj = null;
}
else
{
ItemDataBlock itemDataBlock = ((Item)item).ItemDataBlock;
obj = ((itemDataBlock != null) ? new InventorySlot?(itemDataBlock.inventorySlot) : null);
}
InventorySlot? val = obj;
return IsValidInventorySlot(val.GetValueOrDefault());
}
public bool IsValidInventorySlot(InventorySlot slot)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return m_allowedSlots.Contains(slot);
}
}
}
