LayerInventory.cs

using System;
using System.Collections.Generic;
using UnityEngine;
 
// Token: 0x0200057C RID: 1404
public class LayerInventory : ELayer
{
    // Token: 0x06002676 RID: 9846 RVA: 0x000D8D98 File Offset: 0x000D6F98
    public static LayerInventory GetTopLayer(Thing t, bool includePlayer = false, InvOwner exclude = null)
    {
        LayerInventory result = null;
        int num = -1;
        foreach (LayerInventory layerInventory in LayerInventory.listInv)
        {
            if (layerInventory.IsPlayerContainer(includePlayer) && layerInventory.Inv != exclude && !layerInventory.Inv.Container.IsToolbelt && !layerInventory.Inv.Container.things.IsFull(t, false, true))
            {
                int siblingIndex = layerInventory.transform.GetSiblingIndex();
                if (siblingIndex > num)
                {
                    num = siblingIndex;
                    result = layerInventory;
                }
            }
        }
        return result;
    }
 
    // Token: 0x06002677 RID: 9847 RVA: 0x000D8E40 File Offset: 0x000D7040
    public static LayerInventory GetPCLayer()
    {
        LayerInventory result = null;
        foreach (LayerInventory layerInventory in LayerInventory.listInv)
        {
            if (layerInventory.Inv.Container.IsPC)
            {
                return layerInventory;
            }
        }
        return result;
    }
 
    // Token: 0x06002678 RID: 9848 RVA: 0x000D8EA8 File Offset: 0x000D70A8
    public static void Close(Thing t)
    {
        foreach (LayerInventory layerInventory in LayerInventory.listInv)
        {
            if (layerInventory.invs[0].owner.Container == t)
            {
                layerInventory.Close();
                break;
            }
        }
    }
 
    // Token: 0x06002679 RID: 9849 RVA: 0x000D8F14 File Offset: 0x000D7114
    public static bool IsOpen(Thing t)
    {
        using (List<LayerInventory>.Enumerator enumerator = LayerInventory.listInv.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                if (enumerator.Current.invs[0].owner.Container == t)
                {
                    return true;
                }
            }
        }
        return false;
    }
 
    // Token: 0x0600267A RID: 9850 RVA: 0x000D8F80 File Offset: 0x000D7180
    public static void SetDirty(Thing t)
    {
        if (!ELayer.game.altInv || t == null)
        {
            return;
        }
        foreach (LayerInventory layerInventory in LayerInventory.listInv)
        {
            if (layerInventory.invs[0].owner.Container == t.parent || (layerInventory.mini && layerInventory.mini.gameObject.activeInHierarchy))
            {
                layerInventory.invs[0].dirty = true;
            }
        }
        if (t.invY == 1 || ELayer.pc.held == t)
        {
            WidgetCurrentTool.dirty = true;
        }
        if (t.isEquipped)
        {
            WidgetEquip.dirty = true;
        }
    }
 
    // Token: 0x0600267B RID: 9851 RVA: 0x000D9054 File Offset: 0x000D7254
    public static void SetDirtyAll(bool immediate = false)
    {
        foreach (LayerInventory layerInventory in LayerInventory.listInv)
        {
            layerInventory.invs[0].dirty = true;
            if (immediate)
            {
                layerInventory.invs[0].CheckDirty();
            }
        }
        if (WidgetEquip.Instance)
        {
            WidgetEquip.dirty = true;
            if (immediate)
            {
                WidgetEquip.Instance.CheckDirty();
            }
        }
        WidgetCurrentTool.dirty = true;
        if (immediate)
        {
            WidgetCurrentTool.Instance.CheckDirty();
        }
    }
 
    // Token: 0x0600267C RID: 9852 RVA: 0x000D90F8 File Offset: 0x000D72F8
    public static void TryShowGuide(UIList list)
    {
        List<ButtonGrid> list2 = new List<ButtonGrid>();
        foreach (UIList.ButtonPair buttonPair in list.buttons)
        {
            ButtonGrid buttonGrid = buttonPair.component as ButtonGrid;
            if (buttonGrid)
            {
                list2.Add(buttonGrid);
            }
        }
        LayerInventory.TryShowGuide(list2);
    }
 
    // Token: 0x0600267D RID: 9853 RVA: 0x000D916C File Offset: 0x000D736C
    public static void TryShowGuide(List<ButtonGrid> list)
    {
        bool flag = InvOwner.HasTrader && InvOwner.Trader.UseGuide;
        bool flag2 = WidgetSearch.Instance && WidgetSearch.selected != null;
        if (!flag2 && WidgetEquip.dragEquip == null && LayerAbility.hotElement == null && !flag)
        {
            return;
        }
        foreach (ButtonGrid buttonGrid in list)
        {
            Thing thing = buttonGrid.card as Thing;
            if (LayerAbility.hotElement != null)
            {
                if ((thing == null || thing.trait is TraitAbility) && buttonGrid.invOwner.owner == ELayer.pc && !(buttonGrid.invOwner is InvOwnerEquip))
                {
                    buttonGrid.Attach("guide", false);
                }
            }
            else if (WidgetEquip.dragEquip != null && !flag)
            {
                InvOwnerEquip invOwnerEquip = buttonGrid.invOwner as InvOwnerEquip;
                if (invOwnerEquip != null && invOwnerEquip.slot.elementId == WidgetEquip.dragEquip.category.slot)
                {
                    buttonGrid.Attach("guide", false);
                }
            }
            else if (flag2)
            {
                if (buttonGrid.card == WidgetSearch.selected || buttonGrid.card == WidgetSearch.selected.parent)
                {
                    buttonGrid.Attach("guide", false);
                }
            }
            else if (thing != null)
            {
                bool show = InvOwner.Trader.ShouldShowGuide(thing);
                if (!show && thing.CanSearchContents)
                {
                    thing.things.Foreach(delegate(Thing _t)
                    {
                        if (!show && InvOwner.Trader.ShouldShowGuide(_t))
                        {
                            show = true;
                        }
                    }, true);
                }
                if (show)
                {
                    buttonGrid.Attach("guide", false);
                }
            }
        }
    }
 
    // Token: 0x17000B8B RID: 2955
    // (get) Token: 0x0600267E RID: 9854 RVA: 0x000D9354 File Offset: 0x000D7554
    public InvOwner Inv
    {
        get
        {
            return this.invs[0].tabs[0].owner;
        }
    }
 
    // Token: 0x0600267F RID: 9855 RVA: 0x000D9374 File Offset: 0x000D7574
    public bool IsPlayerContainer(bool includePlayer = false)
    {
        return this.invs[0].tabs[0].mode == UIInventory.Mode.All && (includePlayer || this.invs[0].owner.Container != ELayer.pc) && this.invs[0].owner.Container.GetRootCard() == ELayer.pc;
    }
 
    // Token: 0x06002680 RID: 9856 RVA: 0x000D93E8 File Offset: 0x000D75E8
    public Card GetPlayerContainer()
    {
        UIInventory.Tab tab = this.invs[0].tabs[0];
        if (!this.IsPlayerContainer(false))
        {
            return null;
        }
        return tab.owner.Container;
    }
 
    // Token: 0x06002681 RID: 9857 RVA: 0x000D9423 File Offset: 0x000D7623
    public override bool HeaderIsListOf(int id)
    {
        return false;
    }
 
    // Token: 0x06002682 RID: 9858 RVA: 0x000D9428 File Offset: 0x000D7628
    public override void OnInit()
    {
        foreach (UIInventory uiinventory in this.invs)
        {
            uiinventory.OnInit();
        }
        LayerInventory.listInv.Add(this);
        if (this.Inv.Container == ELayer.pc)
        {
            InvOwner.Main = this.Inv;
        }
        if (!this.floatInv)
        {
            InvOwner.Trader = this.Inv;
            this.wasInventoryOpen = ELayer.ui.IsInventoryOpen;
            if (!this.wasInventoryOpen)
            {
                ELayer.ui.OpenFloatInv(true);
            }
        }
    }
 
    // Token: 0x06002683 RID: 9859 RVA: 0x000D94D8 File Offset: 0x000D76D8
    public override void OnAfterInit()
    {
        ELayer.core.actionsNextFrame.Add(delegate
        {
            ELayer.core.actionsNextFrame.Add(delegate
            {
                if (this.invs[0] && this.invs[0].gameObject)
                {
                    this.invs[0].RefreshHighlight();
                }
            });
        });
    }
 
    // Token: 0x06002684 RID: 9860 RVA: 0x000D94F5 File Offset: 0x000D76F5
    public UIInventory SetInv(int idWindow = 0)
    {
        UIInventory uiinventory = this.invs[idWindow];
        uiinventory.window = this.windows[idWindow];
        uiinventory.layer = this;
        return uiinventory;
    }
 
    // Token: 0x06002685 RID: 9861 RVA: 0x000D951C File Offset: 0x000D771C
    public override void OnUpdateInput()
    {
        if (EInput.action == EAction.MenuInventory || Input.GetKeyDown(KeyCode.Tab))
        {
            this.Close();
            EInput.WaitReleaseKey();
            return;
        }
        base.OnUpdateInput();
    }
 
    // Token: 0x06002686 RID: 9862 RVA: 0x000D9544 File Offset: 0x000D7744
    public override void OnKill()
    {
        LayerInventory.listInv.Remove(this);
        EInput.haltInput = false;
        if (this.Inv == InvOwner.Trader)
        {
            if (this.Inv.UseGuide)
            {
                LayerInventory.SetDirtyAll(false);
            }
            InvOwner.Trader = null;
            if (!this.wasInventoryOpen && ELayer.ui.IsInventoryOpen)
            {
                ELayer.ui.ToggleInventory(false);
            }
        }
        if (this.Inv.Container == ELayer.pc)
        {
            InvOwner.Main = null;
        }
        if (!ELayer.game.isKilling && this.Inv.owner == ELayer.pc)
        {
            SE.Play("pop_inventory_deactivate");
        }
    }
 
    // Token: 0x06002687 RID: 9863 RVA: 0x000D95E8 File Offset: 0x000D77E8
    private void OnDestroy()
    {
        LayerInventory.SetDirty(this.invs[0].owner.Container.Thing);
        LayerInventory.listInv.Remove(this);
    }
 
    // Token: 0x06002688 RID: 9864 RVA: 0x000D9618 File Offset: 0x000D7818
    public override void OnRightClick()
    {
        if (this.invs[0].isList)
        {
            base.OnRightClick();
        }
        if (!this.invs[0].floatMode && InputModuleEX.GetComponentOf<ButtonGrid>() == null)
        {
            this.Close();
        }
    }
 
    // Token: 0x06002689 RID: 9865 RVA: 0x000D9664 File Offset: 0x000D7864
    public static LayerInventory _Create(string path = "")
    {
        if (ELayer.game.altInv && path.IsEmpty())
        {
            path = "LayerInventoryGrid";
        }
        return Layer.Create(path.IsEmpty() ? "LayerInventory" : ("LayerInventory/" + path)) as LayerInventory;
    }
 
    // Token: 0x0600268A RID: 9866 RVA: 0x000D96B0 File Offset: 0x000D78B0
    public static LayerInventory CreatePCBackpack(bool mousePos = false)
    {
        LayerInventory layerInventory = LayerInventory._Create("LayerInventoryFloatMain");
        Window window = layerInventory.windows[0];
        layerInventory.mainInv = true;
        window.setting.saveWindow = true;
        UIInventory uiinventory = layerInventory.SetInv(0);
        uiinventory.AddTab(new InvOwner(ELayer.pc, null, CurrencyType.None, PriceType.Default), UIInventory.Mode.All);
        uiinventory.SetHeader("stash");
        uiinventory.floatMode = true;
        return layerInventory;
    }
 
    // Token: 0x0600268B RID: 9867 RVA: 0x000D9718 File Offset: 0x000D7918
    public static bool CloseAllyInv(Chara c)
    {
        foreach (LayerInventory layerInventory in LayerInventory.listInv.Copy<LayerInventory>())
        {
            if (layerInventory.Inv.owner == c)
            {
                ELayer.ui.layerFloat.RemoveLayer(layerInventory);
                return true;
            }
        }
        return false;
    }
 
    // Token: 0x0600268C RID: 9868 RVA: 0x000D9788 File Offset: 0x000D7988
    public static void CloseAllyInv()
    {
        foreach (LayerInventory layerInventory in LayerInventory.listInv.Copy<LayerInventory>())
        {
            if (!layerInventory.IsPlayerContainer(true))
            {
                ELayer.ui.layerFloat.RemoveLayer(layerInventory);
            }
        }
    }
 
    // Token: 0x0600268D RID: 9869 RVA: 0x000D97EC File Offset: 0x000D79EC
    public static LayerInventory CreateContainerAlly(Chara owner, Card container)
    {
        LayerInventory.SetDirty(container.Thing);
        LayerInventory.CloseAllyInv();
        LayerInventory layerInventory = LayerInventory._Create("LayerInventoryFloat");
        UIInventory uiinventory = layerInventory.SetInv(0);
        Window window = layerInventory.windows[0];
        window.buttonClose.SetActive(true);
        uiinventory.AddTab(new InvOwnerAlly(owner, container.Thing, CurrencyType.Money), UIInventory.Mode.All);
        uiinventory.tabs[0].textTab = container.Name;
        uiinventory.floatMode = true;
        if (ELayer.player.windowAllyInv == null)
        {
            Vector2 sizeDelta = window.Rect().sizeDelta;
            ELayer.player.windowAllyInv = new Window.SaveData
            {
                x = 0f,
                y = 200f,
                w = sizeDelta.x,
                h = sizeDelta.y,
                anchor = RectPosition.Center,
                useBG = ELayer.core.config.game.showInvBG,
                advDistribution = false
            };
        }
        window.saveData = ELayer.player.windowAllyInv;
        window.saveData.open = true;
        ELayer.ui.layerFloat.AddLayer(layerInventory);
        window.ClampToScreen();
        window.UpdateSaveData();
        return layerInventory;
    }
 
    // Token: 0x0600268E RID: 9870 RVA: 0x000D9920 File Offset: 0x000D7B20
    public static bool IsOpen(Card container)
    {
        using (List<LayerInventory>.Enumerator enumerator = LayerInventory.listInv.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                if (enumerator.Current.GetPlayerContainer() == container)
                {
                    return true;
                }
            }
        }
        return false;
    }
 
    // Token: 0x0600268F RID: 9871 RVA: 0x000D997C File Offset: 0x000D7B7C
    public static LayerInventory CreateContainerPC(Card container)
    {
        LayerInventory.SetDirty(container.Thing);
        foreach (LayerInventory layerInventory in LayerInventory.listInv)
        {
            if (layerInventory.GetPlayerContainer() == container)
            {
                ELayer.ui.layerFloat.RemoveLayer(layerInventory);
                return null;
            }
        }
        LayerInventory layerInventory2 = LayerInventory._Create("LayerInventoryFloat");
        UIInventory uiinventory = layerInventory2.SetInv(0);
        Window window = layerInventory2.windows[0];
        Vector2 vector = default(Vector2);
        bool flag = container.c_windowSaveData == null;
        window.buttonClose.SetActive(true);
        uiinventory.AddTab(new InvOwner(ELayer.pc, container.Thing, CurrencyType.None, PriceType.Default), UIInventory.Mode.All);
        uiinventory.tabs[0].textTab = container.Name;
        uiinventory.floatMode = true;
        if (container.c_windowSaveData == null)
        {
            vector = window.Rect().anchoredPosition + new Vector2(-80f, -80f);
            Vector2 sizeDelta = window.Rect().sizeDelta;
            container.c_windowSaveData = new Window.SaveData
            {
                x = vector.x,
                y = vector.y,
                w = sizeDelta.x,
                h = sizeDelta.y,
                anchor = RectPosition.Auto,
                useBG = ELayer.core.config.game.showInvBG,
                advDistribution = false
            };
            if (container.trait.IsFridge)
            {
                container.c_windowSaveData.onlyRottable = true;
            }
        }
        if (container.IsToolbelt)
        {
            container.c_windowSaveData.useBG = false;
        }
        window.saveData = container.c_windowSaveData;
        window.saveData.open = true;
        if (container.IsToolbelt)
        {
            return layerInventory2;
        }
        ELayer.ui.layerFloat.AddLayer(layerInventory2);
        if (flag)
        {
            RectTransform rectTransform = window.Rect();
            RectTransform rectTransform2 = null;
            RectTransform rectTransform3 = null;
            foreach (LayerInventory layerInventory3 in LayerInventory.listInv)
            {
                if (!(layerInventory3 == layerInventory2) && layerInventory3.IsFloat)
                {
                    RectTransform rectTransform4 = layerInventory3.windows[0].Rect();
                    if (!rectTransform3 || rectTransform4.Rect().localPosition.x < rectTransform3.Rect().localPosition.x)
                    {
                        rectTransform3 = rectTransform4;
                    }
                    if (!rectTransform2 || rectTransform4.Rect().localPosition.y > rectTransform2.Rect().localPosition.y)
                    {
                        rectTransform2 = rectTransform4;
                    }
                }
            }
            if (uiinventory.tabs[0].owner.Container.things.width < 3 && rectTransform3)
            {
                rectTransform.anchorMin = rectTransform3.anchorMin;
                rectTransform.anchorMax = rectTransform3.anchorMax;
                vector.x = rectTransform3.anchoredPosition.x - rectTransform.sizeDelta.x - rectTransform3.sizeDelta.x * 0.5f + 35f;
                vector.y = rectTransform3.anchoredPosition.y;
            }
            else if (rectTransform2)
            {
                rectTransform.anchorMin = rectTransform2.anchorMin;
                rectTransform.anchorMax = rectTransform2.anchorMax;
                vector.x = rectTransform2.anchoredPosition.x;
                vector.y = rectTransform2.anchoredPosition.y + rectTransform.sizeDelta.y - 25f;
            }
            else
            {
                rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
                rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
                vector = Vector2.one;
            }
            rectTransform.anchoredPosition = vector;
            window.ClampToScreen();
            window.UpdateSaveData();
        }
        return layerInventory2;
    }
 
    // Token: 0x06002690 RID: 9872 RVA: 0x000D9D90 File Offset: 0x000D7F90
    public static LayerInventory CreateContainer(Card owner)
    {
        if (owner.GetRootCard() == ELayer.pc)
        {
            return LayerInventory.CreateContainerPC(owner);
        }
        Card container = owner;
        if (owner.trait is TraitShippingChest)
        {
            container = ELayer.game.cards.container_shipping;
            ELayer.player.uidLastShippedZone = ELayer._zone.uid;
        }
        if (owner.trait is TraitDeliveryChest)
        {
            container = ELayer.game.cards.container_deliver;
            Tutorial.Play("deliver_box");
        }
        return LayerInventory.CreateContainer(owner, container);
    }
 
    // Token: 0x06002691 RID: 9873 RVA: 0x000D9E14 File Offset: 0x000D8014
    public static LayerInventory CreateContainer(Card owner, Card container)
    {
        if (container.isChara)
        {
            SE.PopInventory();
        }
        LayerInventory layerInventory = LayerInventory._Create("");
        layerInventory.SetInv(0).AddTab(owner, UIInventory.Mode.Take, container.Thing).dest = ELayer.pc;
        if (container.c_windowSaveData == null)
        {
            container.c_windowSaveData = new Window.SaveData
            {
                useBG = true
            };
            if (container == ELayer.game.cards.container_shipping)
            {
                container.c_windowSaveData.autodump = AutodumpFlag.none;
            }
        }
        layerInventory.windows[0].saveData = container.c_windowSaveData;
        ELayer.ui.AddLayer(layerInventory);
        return layerInventory;
    }
 
    // Token: 0x06002692 RID: 9874 RVA: 0x000D9EB4 File Offset: 0x000D80B4
    public static LayerInventory CreateContainer<T>(Card c, Card container, CurrencyType currency = CurrencyType.None) where T : InvOwner
    {
        LayerInventory layerInventory = LayerInventory._Create("");
        UIInventory uiinventory = layerInventory.SetInv(0);
        T t = Activator.CreateInstance(typeof(T), new object[]
        {
            c,
            container,
            currency
        }) as T;
        uiinventory.AddTab(t, UIInventory.Mode.Buy).dest = ELayer.pc;
        if (container.c_windowSaveData == null)
        {
            container.c_windowSaveData = new Window.SaveData
            {
                useBG = true
            };
        }
        layerInventory.windows[0].saveData = container.c_windowSaveData;
        ELayer.ui.AddLayer(layerInventory);
        return layerInventory;
    }
 
    // Token: 0x06002693 RID: 9875 RVA: 0x000D9F5C File Offset: 0x000D815C
    public static LayerInventory CreateBuy(Card c, CurrencyType currency = CurrencyType.Money, PriceType price = PriceType.Default)
    {
        LayerInventory layerInventory = LayerInventory._Create("");
        UIInventory uiinventory = layerInventory.SetInv(0);
        Thing thing = c.things.Find("chest_merchant", -1, -1);
        SE.Play("shop_open");
        InvOwnerShop invOwnerShop = new InvOwnerShop(c, thing, currency, price);
        uiinventory.AddTab(invOwnerShop, UIInventory.Mode.Buy).dest = ELayer.pc;
        if (Window.dictData.TryGetValue("ChestMerchant", null) == null)
        {
            Window.dictData.Add("ChestMerchant", new Window.SaveData
            {
                useBG = true
            });
        }
        layerInventory.windows[0].saveData = thing.GetWindowSaveData();
        uiinventory.tabs[0].owner.BuildUICurrency(layerInventory.uiCurrency, c.trait.CostRerollShop != 0);
        ShopTransaction.current = new ShopTransaction
        {
            trader = invOwnerShop
        };
        layerInventory.SetOnKill(new Action(ShopTransaction.current.OnEndTransaction));
        return layerInventory;
    }
 
    // Token: 0x0400151A RID: 5402
    public static List<LayerInventory> listInv = new List<LayerInventory>();
 
    // Token: 0x0400151B RID: 5403
    public static InvOwner highlightInv;
 
    // Token: 0x0400151C RID: 5404
    public List<UIInventory> invs = new List<UIInventory>();
 
    // Token: 0x0400151D RID: 5405
    public UICurrency uiCurrency;
 
    // Token: 0x0400151E RID: 5406
    public bool floatInv;
 
    // Token: 0x0400151F RID: 5407
    public bool mainInv;
 
    // Token: 0x04001520 RID: 5408
    public WindowCharaMini mini;
 
    // Token: 0x04001521 RID: 5409
    [NonSerialized]
    public bool wasInventoryOpen;
}