InvOwner.cs

using System;
using System.Collections.Generic;
using UnityEngine;
 
// Token: 0x02000560 RID: 1376
public class InvOwner : EClass
{
    // Token: 0x17000B25 RID: 2853
    // (get) Token: 0x06002561 RID: 9569 RVA: 0x000D4FF6 File Offset: 0x000D31F6
    public static bool HasTrader
    {
        get
        {
            return InvOwner.Trader != null;
        }
    }
 
    // Token: 0x17000B26 RID: 2854
    // (get) Token: 0x06002562 RID: 9570 RVA: 0x000D5000 File Offset: 0x000D3200
    public static bool FreeTransfer
    {
        get
        {
            return !InvOwner.HasTrader || InvOwner.Trader.currency == CurrencyType.None;
        }
    }
 
    // Token: 0x17000B27 RID: 2855
    // (get) Token: 0x06002563 RID: 9571 RVA: 0x000D5018 File Offset: 0x000D3218
    public virtual bool AllowAutouse
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000B28 RID: 2856
    // (get) Token: 0x06002564 RID: 9572 RVA: 0x000D501B File Offset: 0x000D321B
    public virtual bool AllowContext
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000B29 RID: 2857
    // (get) Token: 0x06002565 RID: 9573 RVA: 0x000D501E File Offset: 0x000D321E
    public virtual bool AllowSell
    {
        get
        {
            return this.currency == CurrencyType.None || this.owner.trait.AllowSell;
        }
    }
 
    // Token: 0x06002566 RID: 9574 RVA: 0x000D503C File Offset: 0x000D323C
    public virtual bool AllowHold(Thing t)
    {
        if (!t.trait.CanBeDropped)
        {
            return false;
        }
        if (t.isEquipped && t.IsCursed)
        {
            return false;
        }
        if (this.Container.isChara && !this.Container.IsPC)
        {
            return !(t.id == "money") && (!t.isEquipped && !t.isGifted) && !t.isNPCProperty;
        }
        return !t.trait.CanOnlyCarry && (!this.Container.isNPCProperty || !InvOwner.FreeTransfer);
    }
 
    // Token: 0x06002567 RID: 9575 RVA: 0x000D50DA File Offset: 0x000D32DA
    public virtual bool AllowMoved(Thing t)
    {
        return true;
    }
 
    // Token: 0x17000B2A RID: 2858
    // (get) Token: 0x06002568 RID: 9576 RVA: 0x000D50DD File Offset: 0x000D32DD
    public virtual bool AlwaysShowTooltip
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000B2B RID: 2859
    // (get) Token: 0x06002569 RID: 9577 RVA: 0x000D50E0 File Offset: 0x000D32E0
    public virtual bool UseGuide
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x0600256A RID: 9578 RVA: 0x000D50E3 File Offset: 0x000D32E3
    public virtual bool ShouldShowGuide(Thing t)
    {
        return false;
    }
 
    // Token: 0x17000B2C RID: 2860
    // (get) Token: 0x0600256B RID: 9579 RVA: 0x000D50E6 File Offset: 0x000D32E6
    public virtual bool AllowTransfer
    {
        get
        {
            return this.Container.isChara || !this.Container.isNPCProperty;
        }
    }
 
    // Token: 0x17000B2D RID: 2861
    // (get) Token: 0x0600256C RID: 9580 RVA: 0x000D5105 File Offset: 0x000D3305
    public virtual bool AllowDropOnDrag
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x0600256D RID: 9581 RVA: 0x000D5108 File Offset: 0x000D3308
    public virtual bool AllowDrop(Thing t)
    {
        return !EClass._zone.IsRegion || t.trait is TraitAbility;
    }
 
    // Token: 0x17000B2E RID: 2862
    // (get) Token: 0x0600256E RID: 9582 RVA: 0x000D5126 File Offset: 0x000D3326
    public virtual string langTransfer
    {
        get
        {
            return "actTransfer";
        }
    }
 
    // Token: 0x17000B2F RID: 2863
    // (get) Token: 0x0600256F RID: 9583 RVA: 0x000D512D File Offset: 0x000D332D
    public virtual int destInvY
    {
        get
        {
            return 0;
        }
    }
 
    // Token: 0x06002570 RID: 9584 RVA: 0x000D5130 File Offset: 0x000D3330
    public virtual Thing CreateDefaultContainer()
    {
        return ThingGen.Create("chest3", -1, -1);
    }
 
    // Token: 0x17000B30 RID: 2864
    // (get) Token: 0x06002571 RID: 9585 RVA: 0x000D513E File Offset: 0x000D333E
    public virtual bool HasTransaction
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000B31 RID: 2865
    // (get) Token: 0x06002572 RID: 9586 RVA: 0x000D5141 File Offset: 0x000D3341
    public virtual bool CopyOnTransfer
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000B32 RID: 2866
    // (get) Token: 0x06002573 RID: 9587 RVA: 0x000D5144 File Offset: 0x000D3344
    public virtual bool SingleTarget
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x06002574 RID: 9588 RVA: 0x000D5148 File Offset: 0x000D3348
    public virtual void BuildUICurrency(UICurrency uiCurrency, bool canReroll = false)
    {
        bool flag = this.Container.isChara && !this.Container.IsPC;
        uiCurrency.SetActive(this.currency > CurrencyType.None || flag);
        uiCurrency.target = this.owner;
        if (this.currency > CurrencyType.None || flag)
        {
            uiCurrency.Build(new UICurrency.Options
            {
                weight = flag,
                money = (this.currency == CurrencyType.Money),
                plat = (this.currency == CurrencyType.Plat),
                medal = (this.currency == CurrencyType.Medal),
                money2 = (this.currency == CurrencyType.Money2),
                influence = (this.currency == CurrencyType.Influence),
                casino = (this.currency == CurrencyType.Casino_coin),
                ecopo = (this.currency == CurrencyType.Ecopo)
            });
        }
    }
 
    // Token: 0x17000B33 RID: 2867
    // (get) Token: 0x06002575 RID: 9589 RVA: 0x000D5219 File Offset: 0x000D3419
    public bool UseHomeResource
    {
        get
        {
            return this.homeResource != null;
        }
    }
 
    // Token: 0x17000B34 RID: 2868
    // (get) Token: 0x06002576 RID: 9590 RVA: 0x000D5224 File Offset: 0x000D3424
    public bool IsMagicChest
    {
        get
        {
            return this.Container.trait is TraitMagicChest;
        }
    }
 
    // Token: 0x17000B35 RID: 2869
    // (get) Token: 0x06002577 RID: 9591 RVA: 0x000D5239 File Offset: 0x000D3439
    public List<Thing> Things
    {
        get
        {
            if (!this.Container.things.HasGrid)
            {
                return this.Container.things;
            }
            return this.Container.things.grid;
        }
    }
 
    // Token: 0x17000B36 RID: 2870
    // (get) Token: 0x06002578 RID: 9592 RVA: 0x000D5269 File Offset: 0x000D3469
    public Chara Chara
    {
        get
        {
            return this.owner as Chara;
        }
    }
 
    // Token: 0x17000B37 RID: 2871
    // (get) Token: 0x06002579 RID: 9593 RVA: 0x000D5276 File Offset: 0x000D3476
    public ContainerType ContainerType
    {
        get
        {
            return this.Container.trait.ContainerType;
        }
    }
 
    // Token: 0x17000B38 RID: 2872
    // (get) Token: 0x0600257A RID: 9594 RVA: 0x000D5288 File Offset: 0x000D3488
    public virtual bool InvertSell
    {
        get
        {
            return false;
        }
    }
 
    // Token: 0x17000B39 RID: 2873
    // (get) Token: 0x0600257B RID: 9595 RVA: 0x000D528B File Offset: 0x000D348B
    public virtual int numDragGrid
    {
        get
        {
            return 1;
        }
    }
 
    // Token: 0x17000B3A RID: 2874
    // (get) Token: 0x0600257C RID: 9596 RVA: 0x000D528E File Offset: 0x000D348E
    public virtual bool ShowNew
    {
        get
        {
            return this.owner.IsPC;
        }
    }
 
    // Token: 0x17000B3B RID: 2875
    // (get) Token: 0x0600257D RID: 9597 RVA: 0x000D529B File Offset: 0x000D349B
    public virtual bool DenyImportant
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x0600257E RID: 9598 RVA: 0x000D529E File Offset: 0x000D349E
    public bool IsWeightOver(Thing t)
    {
        return false;
    }
 
    // Token: 0x17000B3C RID: 2876
    // (get) Token: 0x0600257F RID: 9599 RVA: 0x000D52A1 File Offset: 0x000D34A1
    public InvOwner destInvOwner
    {
        get
        {
            if (!this.owner.IsPC)
            {
                return InvOwner.Main;
            }
            return InvOwner.Trader;
        }
    }
 
    // Token: 0x06002580 RID: 9600 RVA: 0x000D52BC File Offset: 0x000D34BC
    public InvOwner(Card owner, Card container = null, CurrencyType _currency = CurrencyType.None, PriceType _price = PriceType.Default)
    {
        this.currency = _currency;
        this.priceType = _price;
        this.owner = owner;
        this.Container = (container ?? owner);
        if (this.currency == CurrencyType.BranchMoney)
        {
            this.homeResource = EClass.BranchOrHomeBranch.resources.money;
        }
    }
 
    // Token: 0x06002581 RID: 9601 RVA: 0x000D531C File Offset: 0x000D351C
    public void Init()
    {
        if (this.owner == null)
        {
            CardBlueprint.SetNormalRarity(false);
            this.owner = this.CreateDefaultContainer();
            this.owner.c_lockLv = 0;
            this.owner.c_IDTState = 0;
            this.Container = (this.Container ?? this.owner);
        }
        this.OnInit();
        InvOwner.forceGive = new InvOwner.ForceGiveData();
    }
 
    // Token: 0x06002582 RID: 9602 RVA: 0x000D5381 File Offset: 0x000D3581
    public virtual void OnInit()
    {
    }
 
    // Token: 0x06002583 RID: 9603 RVA: 0x000D5384 File Offset: 0x000D3584
    public virtual void OnClick(ButtonGrid button)
    {
        Card card = button.card;
        Card card2 = button.invOwner.owner;
        if (card != null && EClass.ui.currentDrag == null)
        {
            bool flag = false;
            if (card.Thing.isEquipped && card.Thing.IsEquipmentOrRanged && card.Thing.IsCursed)
            {
                SE.Play("curse3");
            }
            else if (!this.AllowHold(card.Thing) && card2.isChara && !card2.IsPC && card2.IsPCFaction)
            {
                if (InvOwner.forceGive.card != card)
                {
                    InvOwner.forceGive.card = card;
                    InvOwner.forceGive.tries = 0;
                }
                else
                {
                    if (!EInput.isShiftDown)
                    {
                        InvOwner.forceGive.tries++;
                    }
                    if (InvOwner.forceGive.tries >= 2)
                    {
                        if (card.HasTag(CTAG.gift) && card.isGifted)
                        {
                            EClass.ui.CloseLayers();
                            card2.Say("angry", card2, null, null);
                            card2.ShowEmo(Emo.angry, 0f, true);
                            card2.Talk("noGiveRing", null, null, false);
                            card2.Chara.ModAffinity(EClass.pc, -30, true);
                            card2.Chara.InstantEat(card.Thing, true);
                            return;
                        }
                        InvOwner.forceGive.card = null;
                        bool flag2 = card.trait is TraitCurrency;
                        card.isGifted = false;
                        card.isNPCProperty = false;
                        card2.Talk(flag2 ? "forceGiveCurrency" : "forceGive", null, null, false);
                        int num = flag2 ? 3 : 1;
                        if (card.id == "money")
                        {
                            num += card.Num / 1000;
                        }
                        if (num >= 5)
                        {
                            num = 5;
                        }
                        EClass.player.ModKarma(-num);
                        EClass.pc.Pick(card.Thing, true, true);
                        return;
                    }
                }
            }
            if (this.AllowHold(card.Thing) || flag)
            {
                if (EInput.isAltDown)
                {
                    if (this.CanAltClick(button))
                    {
                        this.OnAltClick(button);
                        return;
                    }
                    SE.BeepSmall();
                    return;
                }
                else if (EInput.isCtrlDown)
                {
                    if (this.CanCtrlClick(button))
                    {
                        this.OnCtrlClick(button);
                        return;
                    }
                    SE.BeepSmall();
                    return;
                }
                else if (EInput.isShiftDown)
                {
                    if (this.CanShiftClick(button, false))
                    {
                        this.OnShiftClick(button, false);
                        return;
                    }
                    SE.BeepSmall();
                    return;
                }
                else
                {
                    if (!this.owner.IsPC)
                    {
                        new InvOwner.Transaction(button, (InvOwner.HasTrader && !InvOwner.FreeTransfer) ? 1 : card.Num, null).Process(true);
                        return;
                    }
                    if (button.card != null && this.IsFailByCurse(button.card.Thing))
                    {
                        return;
                    }
                    EClass.ui.StartDrag(new DragItemCard(button, true));
                    return;
                }
            }
            else
            {
                SE.BeepSmall();
                if (card2.isChara && !card2.IsPC)
                {
                    card2.Talk("noGive", null, null, false);
                }
            }
        }
    }
 
    // Token: 0x06002584 RID: 9604 RVA: 0x000D5669 File Offset: 0x000D3869
    public virtual void OnRightClick(ButtonGrid button)
    {
        if (!this.AllowAutouse)
        {
            this.OnClick(button);
        }
        if (button.card == null)
        {
            return;
        }
        this.AutoUse(button, false);
    }
 
    // Token: 0x06002585 RID: 9605 RVA: 0x000D568C File Offset: 0x000D388C
    public virtual void OnRightPressed(ButtonGrid button)
    {
        if (!EInput.rightMouse.pressedLong)
        {
            return;
        }
        float num = 1f;
        float pressedTimer = EInput.rightMouse.pressedTimer;
        if (pressedTimer > 2f)
        {
            num = 2f;
        }
        else if (pressedTimer > 4f)
        {
            num = 5f;
        }
        else if (pressedTimer > 6f)
        {
            num = 50f;
        }
        InvOwner.clickTimer -= Core.delta * num;
        if (InvOwner.clickTimer < 0f)
        {
            InvOwner.clickTimer = 0.1f;
            if (button.card != null)
            {
                this.AutoUse(button, true);
            }
        }
    }
 
    // Token: 0x06002586 RID: 9606 RVA: 0x000D5720 File Offset: 0x000D3920
    public InvOwner GetShitDestOwner(ButtonGrid b, bool rightMouse = false)
    {
        Thing thing = b.card.Thing;
        if (rightMouse && !b.invOwner.owner.IsPC)
        {
            LayerInventory pclayer = LayerInventory.GetPCLayer();
            if (pclayer == null)
            {
                return null;
            }
            return pclayer.Inv;
        }
        else if (InvOwner.Trader != null)
        {
            if (b.invOwner.owner.IsPC)
            {
                if (!InvOwner.Trader.Container.things.IsFull(thing, true, true))
                {
                    return InvOwner.Trader;
                }
                return null;
            }
            else
            {
                LayerInventory topLayer = LayerInventory.GetTopLayer(thing, true, InvOwner.Trader);
                if (topLayer == null)
                {
                    return null;
                }
                return topLayer.Inv;
            }
        }
        else
        {
            LayerInventory topLayer2 = LayerInventory.GetTopLayer(thing, true, this);
            if (topLayer2 == null)
            {
                return null;
            }
            return topLayer2.Inv;
        }
    }
 
    // Token: 0x06002587 RID: 9607 RVA: 0x000D57CC File Offset: 0x000D39CC
    public virtual void OnShiftClick(ButtonGrid b, bool rightMouse = false)
    {
        InvOwner shitDestOwner = this.GetShitDestOwner(b, rightMouse);
        Thing thing = b.card.Thing;
        Card container = shitDestOwner.Container;
        if (rightMouse && !this.owner.IsPC)
        {
            EClass.pc.Pick(thing, false, true);
            return;
        }
        if ((thing.parent == container || thing == container) && !thing.IsHotItem)
        {
            if (EInput.isShiftDown)
            {
                SE.BeepSmall();
            }
            return;
        }
        thing.PlaySoundDrop(false);
        if (thing.IsHotItem && thing.parent == container)
        {
            container.RemoveCard(thing);
        }
        if (container.things.CanStack(thing, -1, -1) != thing)
        {
            container.things.TryStack(thing, -1, -1);
            return;
        }
        container.AddThing(thing, true, -1, -1);
    }
 
    // Token: 0x06002588 RID: 9608 RVA: 0x000D5880 File Offset: 0x000D3A80
    public virtual bool CanShiftClick(ButtonGrid b, bool rightMouse = false)
    {
        if (!EInput.isShiftDown && !rightMouse)
        {
            return false;
        }
        if (!EClass.pc.HasNoGoal || this.Container.isNPCProperty || this.currency != CurrencyType.None)
        {
            return false;
        }
        if (rightMouse && !InvOwner.HasTrader)
        {
            return false;
        }
        if (InvOwner.HasTrader)
        {
            if (InvOwner.Trader is InvOwnerDraglet || InvOwner.Trader.Container.isNPCProperty || InvOwner.Trader.currency != CurrencyType.None)
            {
                return false;
            }
            if (InvOwner.Trader.Container.isChara)
            {
                return false;
            }
            Card card = b.card;
            if (card != null && card.c_isImportant)
            {
                return false;
            }
        }
        InvOwner shitDestOwner = this.GetShitDestOwner(b, rightMouse);
        if (shitDestOwner == null)
        {
            return false;
        }
        Thing thing = b.card.Thing;
        if (thing.trait.IsContainer && thing.things.Count > 0)
        {
            return false;
        }
        if (!this.AllowHold(thing))
        {
            return false;
        }
        if (InvOwner.HasTrader)
        {
            if (!InvOwner.Trader.Container.GetRootCard().IsPC && thing.trait is TraitCatalyst)
            {
                return false;
            }
            if (!InvOwner.Trader.AllowMoved(thing))
            {
                return false;
            }
        }
        if (shitDestOwner.Container.isChara && !shitDestOwner.owner.IsPC && !shitDestOwner.owner.Chara.CanAcceptItem(thing, -1))
        {
            return false;
        }
        if (b.invOwner.owner.isChara && b.invOwner.owner.Chara.IsPCFaction && !b.invOwner.owner.IsPC && thing.IsRangedWeapon)
        {
            thing.ammoData = null;
            thing.c_ammo = 0;
        }
        if (EInput.isShiftDown)
        {
            LayerInventory.highlightInv = shitDestOwner;
        }
        return true;
    }
 
    // Token: 0x06002589 RID: 9609 RVA: 0x000D5A2F File Offset: 0x000D3C2F
    public virtual string GetTextShiftClick(ButtonGrid b)
    {
        return "actTransfer".lang();
    }
 
    // Token: 0x0600258A RID: 9610 RVA: 0x000D5A3B File Offset: 0x000D3C3B
    public virtual void OnCtrlClick(ButtonGrid button)
    {
        button.card.Thing.ShowSplitMenu(button, this.HasTransaction ? new InvOwner.Transaction(button, 1, null) : null);
    }
 
    // Token: 0x0600258B RID: 9611 RVA: 0x000D5A61 File Offset: 0x000D3C61
    public virtual bool CanCtrlClick(ButtonGrid b)
    {
        return EInput.isCtrlDown && EClass.pc.HasNoGoal && !this.Container.isNPCProperty && b.card.Num > 1;
    }
 
    // Token: 0x0600258C RID: 9612 RVA: 0x000D5A96 File Offset: 0x000D3C96
    public virtual string GetTextCtrlClick(ButtonGrid b)
    {
        return "actSplit".lang();
    }
 
    // Token: 0x0600258D RID: 9613 RVA: 0x000D5AA2 File Offset: 0x000D3CA2
    public virtual void OnAltClick(ButtonGrid button)
    {
        EClass.pc.DropThing(button.card.Thing, -1);
    }
 
    // Token: 0x0600258E RID: 9614 RVA: 0x000D5ABC File Offset: 0x000D3CBC
    public virtual bool CanAltClick(ButtonGrid b)
    {
        return EInput.isAltDown && EClass.pc.HasNoGoal && !this.Container.isNPCProperty && this.currency == CurrencyType.None && this.AllowDrop(b.card.Thing);
    }
 
    // Token: 0x0600258F RID: 9615 RVA: 0x000D5B0B File Offset: 0x000D3D0B
    public virtual string GetTextAltClick(ButtonGrid b)
    {
        return "actDrop".lang();
    }
 
    // Token: 0x06002590 RID: 9616 RVA: 0x000D5B18 File Offset: 0x000D3D18
    public void Grab(DragItemCard.DragInfo from)
    {
        bool isEquipped = from.thing.isEquipped;
        if (isEquipped)
        {
            from.invOwner.owner.Chara.body.Unequip(from.thing, true);
        }
        from.invOwner.Container.RemoveCard(from.thing);
        if (isEquipped)
        {
            from.list.Redraw();
        }
        LayerInventory.SetDirty(from.thing);
    }
 
    // Token: 0x06002591 RID: 9617 RVA: 0x000D5B84 File Offset: 0x000D3D84
    public Thing PutBack(DragItemCard.DragInfo from)
    {
        Thing thing = from.thing;
        if (from.invY == 1 && from.container.things.IsOccupied(from.invX, from.invY))
        {
            return EClass.pc.Pick(thing, false, true);
        }
        if (from.container.things.IsFull(thing, false, false))
        {
            return EClass.pc.Pick(thing, false, true);
        }
        thing.invY = from.invY;
        thing = from.container.AddThing(thing, true, from.invX, from.invY);
        if (from.equippedSlot != null)
        {
            from.invOwner.owner.Chara.body.Equip(thing, from.equippedSlot, true);
            from.list.Redraw();
        }
        else
        {
            thing.invX = from.invX;
        }
        if (from.invY == 1)
        {
            WidgetCurrentTool.dirty = true;
        }
        return thing;
    }
 
    // Token: 0x06002592 RID: 9618 RVA: 0x000D5C6A File Offset: 0x000D3E6A
    public void OnStartDrag(DragItemCard.DragInfo from)
    {
        from.thing.PlaySoundDrop(false);
        if (from.thing.parent != null)
        {
            this.Grab(from);
        }
        if (from.thing.IsEquipment)
        {
            WidgetEquip.dragEquip = from.thing;
            WidgetEquip.Redraw();
        }
    }
 
    // Token: 0x06002593 RID: 9619 RVA: 0x000D5CA9 File Offset: 0x000D3EA9
    public virtual bool OnCancelDrag(DragItemCard.DragInfo from)
    {
        if (this.Container.isNPCProperty)
        {
            return false;
        }
        this.PutBack(from);
        return true;
    }
 
    // Token: 0x06002594 RID: 9620 RVA: 0x000D5CC4 File Offset: 0x000D3EC4
    public bool OnDrag(DragItemCard.DragInfo from, DragItemCard.DragInfo to, bool execute, bool cancel = false)
    {
        if (cancel)
        {
            return this.OnCancelDrag(from);
        }
        bool flag = false;
        string text = "";
        if (EClass.ui.GetLayer<LayerRegisterHotbar>(false) == null)
        {
            EClass.ui.AddLayer<LayerRegisterHotbar>().SetItem(from.thing);
        }
        LayerInventory componentOf = InputModuleEX.GetComponentOf<LayerInventory>();
        if (!EClass.ui.isPointerOverUI && !EClass._zone.IsRegion)
        {
            flag = this.AllowDropOnDrag;
            text = ((!this.AllowDropOnDrag) ? "" : ((from.thing.trait is TraitAbility) ? "dragForget" : "dragDropThing"));
            if (execute)
            {
                if (!this.AllowDropOnDrag || from.thing.c_isImportant)
                {
                    return this.OnCancelDrag(from);
                }
                EClass.pc.DropThing(from.thing, -1);
                return true;
            }
        }
        else if (!EClass.core.config.game.useGrid && componentOf)
        {
            if (to.button && to.invOwner != null && to.thing != null && to.thing.CanStackTo(from.thing))
            {
                InvOwner.Transaction transaction = new InvOwner.Transaction(from, to, from.thing.Num);
                flag = transaction.IsValid();
                text = transaction.GetTextDetail();
                if (execute)
                {
                    return transaction.Process(false);
                }
            }
            else
            {
                InvOwner.Transaction transaction2 = new InvOwner.Transaction(from, componentOf.invs[0], from.thing.Num);
                flag = transaction2.IsValid();
                text = transaction2.GetTextDetail();
                if (execute)
                {
                    return transaction2.Process(false);
                }
            }
        }
        else if (to.button && to.invOwner != null && to.button.interactable)
        {
            if (to.invOwner is InvOwnerEquip)
            {
                InvOwnerEquip invOwnerEquip = to.invOwner as InvOwnerEquip;
                Chara chara = invOwnerEquip.owner.Chara;
                BodySlot slot = invOwnerEquip.slot;
                if (execute && to.thing != null && to.thing.blessedState <= BlessedState.Cursed)
                {
                    Msg.Say("unequipCursed", to.thing, null, null, null);
                    return false;
                }
                if (from.thing.category.slot == slot.elementId)
                {
                    flag = true;
                    text = "dragEquip";
                    if (execute)
                    {
                        if (!chara.body.IsEquippable(from.thing, slot, true))
                        {
                            return false;
                        }
                        chara.AddCard(from.thing);
                        if (to.thing != null)
                        {
                            EClass.ui.nextDrag = new DragItemCard(to.button, true);
                            this.Grab(to);
                        }
                        chara.body.Equip(from.thing, invOwnerEquip.slot, true);
                        EClass.Sound.Play("equip");
                        if (EClass.game.UseGrid)
                        {
                            from.list.Redraw();
                        }
                        to.list.Redraw();
                        to.invOwner.OnProcess(from.thing);
                        return true;
                    }
                }
            }
            else
            {
                if (to.invOwner is InvOwnerCopyShop && !to.invOwner.owner.trait.CanCopy(from.thing))
                {
                    return false;
                }
                if (!to.invOwner.AllowTransfer)
                {
                    return false;
                }
                InvOwner.Transaction transaction3 = new InvOwner.Transaction(from, to, from.thing.Num);
                flag = transaction3.IsValid();
                text = transaction3.GetTextDetail();
                if (execute)
                {
                    return transaction3.Process(false);
                }
            }
        }
        EClass.ui.hud.SetDragText(flag ? text : "", (from.thing.Num > 1) ? (from.thing.Num.ToString() ?? "") : null);
        CursorSystem.SetCursor(flag ? null : CursorSystem.Invalid, 100);
        return false;
    }
 
    // Token: 0x06002595 RID: 9621 RVA: 0x000D607C File Offset: 0x000D427C
    public virtual void OnProcess(Thing t)
    {
    }
 
    // Token: 0x06002596 RID: 9622 RVA: 0x000D607E File Offset: 0x000D427E
    public bool CanOpenContainer(Thing t)
    {
        if (!t.trait.CanOpenContainer)
        {
            return false;
        }
        if (t.parent != EClass.pc)
        {
            Thing thing = t.parent as Thing;
            return ((thing != null) ? thing.trait : null) is TraitToolBelt;
        }
        return true;
    }
 
    // Token: 0x06002597 RID: 9623 RVA: 0x000D60C0 File Offset: 0x000D42C0
    public InvOwner.ListInteraction ListInteractions(ButtonGrid b, bool context)
    {
        InvOwner.ListInteraction listInteraction = new InvOwner.ListInteraction();
        if (b == null || b.card == null || this is InvOwnerAlly)
        {
            return listInteraction;
        }
        Thing t = b.card.Thing;
        if (t == null)
        {
            return listInteraction;
        }
        Trait trait = t.trait;
        bool flag = trait is TraitAbility;
        if (InvOwner.HasTrader)
        {
            if (InvOwner.Trader == null || this.destInvOwner == null)
            {
                return listInteraction;
            }
            if (this.CanOpenContainer(t))
            {
                listInteraction.Add("actContainer", 10, delegate()
                {
                    (t.trait as TraitContainer).TryOpen();
                });
            }
            bool flag2 = !flag && !trait.CanOnlyCarry && (!this.destInvOwner.UseGuide || this.destInvOwner.ShouldShowGuide(t));
            bool flag3 = ShopTransaction.current != null && ShopTransaction.current.CanSellBack(t, -1);
            if (this.destInvOwner == InvOwner.Trader && !InvOwner.Trader.AllowSell && !flag3)
            {
                flag2 = false;
            }
            if (!this.AllowHold(t))
            {
                flag2 = false;
            }
            if (!InvOwner.Trader.AllowMoved(t))
            {
                flag2 = false;
            }
            if (flag2 && (!t.c_isImportant || !this.destInvOwner.DenyImportant))
            {
                if (!flag3 && (InvOwner.Trader.currency == CurrencyType.None || t.GetPrice(CurrencyType.Money, false, PriceType.Default, null) == 0))
                {
                    InvOwner.Transaction trans = new InvOwner.Transaction(b, t.Num, null);
                    if (trans.IsValid())
                    {
                        Action <>9__5;
                        listInteraction.Add(this.Container.isNPCProperty ? "actSteal".lang().TagColor(FontColor.Bad, SkinManager.DarkColors) : this.destInvOwner.langTransfer, 0, delegate()
                        {
                            if (this.Container.isNPCProperty)
                            {
                                Action action;
                                if ((action = <>9__5) == null)
                                {
                                    action = (<>9__5 = delegate()
                                    {
                                        trans.Process(false);
                                    });
                                }
                                Dialog.TryWarnCrime(action);
                                return;
                            }
                            trans.Process(false);
                        });
                    }
                }
                else
                {
                    bool isShiftDown = EInput.isShiftDown;
                    InvOwner.Transaction trans = new InvOwner.Transaction(b, 1, null);
                    listInteraction.Add(trans.GetTextDetail(), 0, delegate()
                    {
                        trans.Process(false);
                    }).repeatable = true;
                    if (t.Num > 1)
                    {
                        InvOwner.Transaction trans2 = new InvOwner.Transaction(b, t.Num, null);
                        listInteraction.Add(trans2.GetTextDetail(), 10, delegate()
                        {
                            trans2.Process(false);
                        });
                        if (isShiftDown)
                        {
                            listInteraction.Add(listInteraction[0]);
                            listInteraction.RemoveAt(0);
                        }
                    }
                }
            }
        }
        this.ListInteractions(listInteraction, t, trait, b, context);
        if (this.AllowHold(t) && !t.isEquipped && !InvOwner.HasTrader)
        {
            InvOwner.Interaction item = listInteraction.Add((EClass.pc.held == t) ? "actPick" : "actHold", 60, delegate()
            {
                this.TryHold(t);
            });
            if (t.trait.HoldAsDefaultInteraction)
            {
                listInteraction.Remove(item);
                listInteraction.Insert(0, item);
            }
            if (t.trait.CanBeHeldAsFurniture)
            {
                listInteraction.Add("actHoldTool", 70, delegate()
                {
                    if (t != EClass.pc.held)
                    {
                        if (this.TryHold(t))
                        {
                            HotItemHeld.disableTool = true;
                            return;
                        }
                    }
                    else
                    {
                        HotItemHeld.disableTool = true;
                    }
                });
            }
        }
        if (context && this.AllowHold(t) && !this.Container.isNPCProperty)
        {
            if (t.Num > 1)
            {
                listInteraction.Add("actSplit", 50, delegate()
                {
                    t.ShowSplitMenu(b, (InvOwner.HasTrader && this.currency != CurrencyType.None && !this.owner.IsPC) ? new InvOwner.Transaction(b, 1, null) : null);
                });
            }
            if (this.owner.IsPC && this.AllowDrop(t))
            {
                if (EClass.core.config.game.advancedMenu)
                {
                    listInteraction.Add(t.c_isImportant ? "important_off" : "important_on", 299, delegate()
                    {
                        t.c_isImportant = !t.c_isImportant;
                        LayerInventory.SetDirty(t);
                        SE.ClickOk();
                    });
                }
                if (!EClass._zone.IsRegion)
                {
                    listInteraction.Add(flag ? "dragForget" : "actDrop", 300, delegate()
                    {
                        EClass.pc.DropThing(t, -1);
                    });
                }
            }
        }
        return listInteraction;
    }
 
    // Token: 0x06002598 RID: 9624 RVA: 0x000D6558 File Offset: 0x000D4758
    public bool TryHold(Thing t)
    {
        if (!this.AllowHold(t) || t.isEquipped || InvOwner.HasTrader)
        {
            return false;
        }
        if (EClass.pc.held == t)
        {
            if (t.trait.CanOnlyCarry)
            {
                SE.Beep();
                return true;
            }
            EClass.pc.PickHeld(false);
        }
        else
        {
            EClass.pc.HoldCard(t, -1);
        }
        EClass.player.RefreshCurrentHotItem();
        SE.SelectHotitem();
        return true;
    }
 
    // Token: 0x06002599 RID: 9625 RVA: 0x000D65CC File Offset: 0x000D47CC
    public virtual void ListInteractions(InvOwner.ListInteraction list, Thing t, Trait trait, ButtonGrid b, bool context)
    {
        if (this.owner.IsPC)
        {
            if (this.CanOpenContainer(t) && !list.Contains("actContainer"))
            {
                list.Add(LayerInventory.IsOpen(t) ? "close" : "actContainer", 100, delegate()
                {
                    (t.trait as TraitContainer).TryOpen();
                });
            }
            if (!InvOwner.HasTrader)
            {
                CharaBody body = this.owner.Chara.body;
                BodySlot slot = body.GetSlot(t, false, EInput.isShiftDown);
                if (slot != null)
                {
                    Card tParent = t.parentCard;
                    int tInvX = t.invX;
                    int tInvY = t.invY;
                    if (tInvY != 1)
                    {
                        list.Add("invEquip", 90, delegate()
                        {
                            if (slot.thing != null && slot.thing.blessedState <= BlessedState.Cursed)
                            {
                                Msg.Say("unequipCursed", slot.thing, null, null, null);
                                SE.Play("curse3");
                                return;
                            }
                            if (EClass.pc.held == t)
                            {
                                EClass.pc.PickHeld(false);
                            }
                            Thing thing = slot.thing;
                            body.Equip(t, slot, true);
                            EClass.Sound.Play("equip");
                            if (thing != null)
                            {
                                if (tParent != null)
                                {
                                    tParent.AddThing(thing, true, -1, -1);
                                    thing.invX = tInvX;
                                    thing.invY = tInvY;
                                    return;
                                }
                                if (thing.parent is Card && (thing.parent as Card).things.IsOverflowing())
                                {
                                    thing.parent.RemoveCard(thing);
                                    EClass.pc.Pick(thing, true, true);
                                }
                            }
                        });
                    }
                }
                if (trait.CanRead(EClass.pc))
                {
                    list.Add("invRead", 110, delegate()
                    {
                        t.DoAct(new AI_Read
                        {
                            target = t
                        });
                    });
                }
                if (trait.CanUse(EClass.pc))
                {
                    list.Add(trait.LangUse, 120, delegate()
                    {
                        if (trait.OnUse(EClass.pc))
                        {
                            EClass.player.EndTurn(true);
                        }
                    });
                }
                if (trait.CanDrink(EClass.pc))
                {
                    list.Add("invDrink", 130, delegate()
                    {
                        t.DoAct(new AI_Drink
                        {
                            target = t
                        });
                    });
                }
                if (trait.CanEat(EClass.pc))
                {
                    list.Add("invFood", 140, delegate()
                    {
                        t.DoAct(new AI_Eat
                        {
                            cook = false,
                            target = t
                        });
                    });
                }
                if (context)
                {
                    if (trait.IsBlendBase)
                    {
                        list.Add("invBlend", 150, delegate()
                        {
                            LayerDragGrid.Create(new InvOwnerBlend(t, null, CurrencyType.None), false);
                        });
                    }
                    if (trait is TraitCard)
                    {
                        list.Add("invCollect", 150, delegate()
                        {
                            ContentCodex.Collect(t);
                        });
                    }
                    if (trait.CanName)
                    {
                        Action<bool, string> <>9__9;
                        list.Add("changeName", 200, delegate()
                        {
                            string langDetail = "dialogChangeName";
                            string text2 = t.c_refText.IsEmpty("");
                            Action<bool, string> onClose;
                            if ((onClose = <>9__9) == null)
                            {
                                onClose = (<>9__9 = delegate(bool cancel, string text)
                                {
                                    if (!cancel)
                                    {
                                        t.c_refText = text;
                                    }
                                });
                            }
                            Dialog.InputName(langDetail, text2, onClose, Dialog.InputType.Default);
                        });
                    }
                }
            }
        }
    }
 
    // Token: 0x0600259A RID: 9626 RVA: 0x000D6890 File Offset: 0x000D4A90
    public virtual string GetAutoUseLang(ButtonGrid button)
    {
        if (button == null || button.gameObject == null)
        {
            return "";
        }
        InvOwner.ListInteraction list = this.ListInteractions(button, false);
        if (button.card.trait.HoldAsDefaultInteraction && list.Count > 0)
        {
            InvOwner.Interaction interaction = list[0];
            if (interaction.name == "actPick" || interaction.name == "actHold" || interaction.name == "actHoldTool")
            {
                return null;
            }
        }
        list.ForeachReverse(delegate(InvOwner.Interaction a)
        {
            if (a.name == "actPick" || a.name == "actHold" || a.name == "actHoldTool")
            {
                list.Remove(a);
            }
        });
        if (list.Count == 0)
        {
            return null;
        }
        if (list[0].name == "actTransfer")
        {
            return null;
        }
        return list[0].name.lang();
    }
 
    // Token: 0x0600259B RID: 9627 RVA: 0x000D6990 File Offset: 0x000D4B90
    public void AutoUse(ButtonGrid button, bool repeat = false)
    {
        Card card = button.card;
        if (!ActionMode.Adv.IsActive && !ActionMode.Region.IsActive)
        {
            return;
        }
        if (!EClass.pc.HasNoGoal)
        {
            SE.Beep();
            return;
        }
        InvOwner.ListInteraction listInteraction = this.ListInteractions(button, false);
        if (listInteraction.Count == 0)
        {
            SE.Beep();
            return;
        }
        if (repeat && !listInteraction[0].repeatable)
        {
            return;
        }
        listInteraction[0].action();
    }
 
    // Token: 0x0600259C RID: 9628 RVA: 0x000D6A0C File Offset: 0x000D4C0C
    public void ShowContextMenu(ButtonGrid button)
    {
        if (!EClass.pc.HasNoGoal)
        {
            SE.Beep();
            return;
        }
        InvOwner.ListInteraction listInteraction = this.ListInteractions(button, true);
        if (listInteraction.Count == 0)
        {
            SE.BeepSmall();
            return;
        }
        UIContextMenu uicontextMenu = EClass.ui.CreateContextMenuInteraction();
        listInteraction.Sort((InvOwner.Interaction a, InvOwner.Interaction b) => a.priority - b.priority);
        foreach (InvOwner.Interaction interaction in listInteraction)
        {
            uicontextMenu.AddButton(interaction.name, interaction.action, true);
        }
        uicontextMenu.Show();
    }
 
    // Token: 0x0600259D RID: 9629 RVA: 0x000D6AC8 File Offset: 0x000D4CC8
    public virtual int GetPrice(Thing t, CurrencyType currency, int num, bool sell)
    {
        return ShopTransaction.current.GetPrice(t, num, sell);
    }
 
    // Token: 0x0600259E RID: 9630 RVA: 0x000D6AD8 File Offset: 0x000D4CD8
    public virtual string GetTextDetail(Thing t, CurrencyType currency, int num, bool sell)
    {
        int price = this.GetPrice(t, currency, num, sell);
        string @ref = InvOwner.Trader.UseHomeResource ? InvOwner.Trader.homeResource.Name : ((currency == CurrencyType.Influence) ? "influence".lang() : EClass.sources.things.map[this.IDCurrency].GetName());
        string ref2 = (price == 0) ? "" : "invInteraction3".lang(price.ToString() ?? "", @ref, null, null, null);
        string text = "invInteraction1".lang(num.ToString() ?? "", ref2, (sell ? "invSell" : "invBuy").lang(), null, null);
        if (!sell && EClass.pc.GetCurrency(Currency.ToID(currency)) < price)
        {
            text = text.TagColor(FontColor.Bad, SkinManager.DarkColors);
        }
        return text;
    }
 
    // Token: 0x0600259F RID: 9631 RVA: 0x000D6BC0 File Offset: 0x000D4DC0
    public virtual void OnWriteNote(ButtonGrid button, UINote n)
    {
        Thing thing = button.card as Thing;
        if (thing == null)
        {
            return;
        }
        bool flag;
        if (InvOwner.HasTrader && InvOwner.Trader.currency != CurrencyType.None)
        {
            if (this.destInvOwner == InvOwner.Trader)
            {
                if (!InvOwner.Trader.AllowSell)
                {
                    ShopTransaction current = ShopTransaction.current;
                    flag = (current != null && current.CanSellBack(thing, -1));
                }
                else
                {
                    flag = true;
                }
            }
            else
            {
                flag = true;
            }
        }
        else
        {
            flag = false;
        }
        bool flag2 = flag;
        if (flag2 && InvOwner.Trader.UseGuide && !InvOwner.Trader.ShouldShowGuide(thing))
        {
            flag2 = false;
        }
        if (flag2)
        {
            InvOwner.Transaction transaction = new InvOwner.Transaction(button, 1, null);
            n.Space(8, 1);
            UIItem uiitem = n.AddExtra<UIItem>("costPrice");
            string id = this.IDCostIcon(thing);
            int price = transaction.GetPrice();
            uiitem.text1.SetText(Lang._currency(price, false, 14), transaction.IsValid() ? FontColor.Good : FontColor.Bad);
            uiitem.image1.sprite = (InvOwner.Trader.UseHomeResource ? InvOwner.Trader.homeResource.Sprite : SpriteSheet.Get(id));
        }
    }
 
    // Token: 0x060025A0 RID: 9632 RVA: 0x000D6CC1 File Offset: 0x000D4EC1
    public virtual string IDCostIcon(Thing t)
    {
        return "icon_" + this.IDCurrency;
    }
 
    // Token: 0x17000B3D RID: 2877
    // (get) Token: 0x060025A1 RID: 9633 RVA: 0x000D6CD3 File Offset: 0x000D4ED3
    public string IDCurrency
    {
        get
        {
            return Currency.ToID(InvOwner.Trader.currency);
        }
    }
 
    // Token: 0x060025A2 RID: 9634 RVA: 0x000D6CE4 File Offset: 0x000D4EE4
    public virtual bool IsFailByCurse(Thing t)
    {
        return false;
    }
 
    // Token: 0x040014EA RID: 5354
    public static InvOwner.ForceGiveData forceGive = new InvOwner.ForceGiveData();
 
    // Token: 0x040014EB RID: 5355
    public static InvOwner Trader;
 
    // Token: 0x040014EC RID: 5356
    public static InvOwner Main;
 
    // Token: 0x040014ED RID: 5357
    public static float clickTimer;
 
    // Token: 0x040014EE RID: 5358
    public bool includeChildren;
 
    // Token: 0x040014EF RID: 5359
    public CurrencyType currency;
 
    // Token: 0x040014F0 RID: 5360
    public PriceType priceType;
 
    // Token: 0x040014F1 RID: 5361
    public HomeResource homeResource;
 
    // Token: 0x040014F2 RID: 5362
    public Card owner;
 
    // Token: 0x040014F3 RID: 5363
    public Card Container;
 
    // Token: 0x040014F4 RID: 5364
    public List<ButtonGrid> buttons = new List<ButtonGrid>();
 
    // Token: 0x02000A95 RID: 2709
    public class ErrorMessage
    {
        // Token: 0x06004162 RID: 16738 RVA: 0x00151104 File Offset: 0x0014F304
        public void Set(string _lang, Card c = null, string _sound = "beep_small")
        {
            this.lang = _lang;
            if (c != null)
            {
                this.card = c;
            }
            this.sound = _sound;
        }
 
        // Token: 0x04002B32 RID: 11058
        public string sound = "beep_small";
 
        // Token: 0x04002B33 RID: 11059
        public string lang = "";
 
        // Token: 0x04002B34 RID: 11060
        public Card card;
    }
 
    // Token: 0x02000A96 RID: 2710
    public class ForceGiveData
    {
        // Token: 0x04002B35 RID: 11061
        public Card card;
 
        // Token: 0x04002B36 RID: 11062
        public int tries;
    }
 
    // Token: 0x02000A97 RID: 2711
    public class Transaction
    {
        // Token: 0x170011E1 RID: 4577
        // (get) Token: 0x06004165 RID: 16741 RVA: 0x00151144 File Offset: 0x0014F344
        public InvOwner destInv
        {
            get
            {
                if (this.to != null)
                {
                    return this.to.invOwner;
                }
                if (this.destUIInv != null)
                {
                    return this.destUIInv.owner;
                }
                if (!this.inv.owner.IsPC)
                {
                    return InvOwner.Main;
                }
                return InvOwner.Trader;
            }
        }
 
        // Token: 0x170011E2 RID: 4578
        // (get) Token: 0x06004166 RID: 16742 RVA: 0x0015119C File Offset: 0x0014F39C
        public bool sell
        {
            get
            {
                return (!this.destInv.InvertSell && !this.destInv.owner.IsPC) || (this.destInv.InvertSell && this.destInv.owner.IsPC);
            }
        }
 
        // Token: 0x170011E3 RID: 4579
        // (get) Token: 0x06004167 RID: 16743 RVA: 0x001511EC File Offset: 0x0014F3EC
        public string IDCurrency
        {
            get
            {
                return this.currency.ToString().ToLower();
            }
        }
 
        // Token: 0x170011E4 RID: 4580
        // (get) Token: 0x06004168 RID: 16744 RVA: 0x00151212 File Offset: 0x0014F412
        public CurrencyType currency
        {
            get
            {
                return InvOwner.Trader.currency;
            }
        }
 
        // Token: 0x170011E5 RID: 4581
        // (get) Token: 0x06004169 RID: 16745 RVA: 0x00151220 File Offset: 0x0014F420
        public bool FreeTrade
        {
            get
            {
                return !InvOwner.HasTrader || this.currency == CurrencyType.None || (this.to != null && this.to.invOwner.owner == EClass.pc) || (this.destUIInv && this.destUIInv.owner.owner == EClass.pc);
            }
        }
 
        // Token: 0x0600416A RID: 16746 RVA: 0x00151284 File Offset: 0x0014F484
        public Transaction(DragItemCard.DragInfo from, UIInventory destUIInv, int num = 1)
        {
            this.from = from;
            this.button = from.button;
            this.thing = from.thing;
            this.num = num;
            this.inv = from.invOwner;
            this.destUIInv = destUIInv;
        }
 
        // Token: 0x0600416B RID: 16747 RVA: 0x001512D8 File Offset: 0x0014F4D8
        public Transaction(DragItemCard.DragInfo from, DragItemCard.DragInfo to, int num = 1)
        {
            this.from = from;
            this.to = to;
            this.button = from.button;
            this.thing = from.thing;
            this.num = num;
            this.inv = from.invOwner;
        }
 
        // Token: 0x0600416C RID: 16748 RVA: 0x0015132B File Offset: 0x0014F52B
        public Transaction(ButtonGrid button, int num = 1, InvOwner owner = null)
        {
            this.button = button;
            this.thing = (button.card as Thing);
            this.num = num;
            this.inv = (owner ?? button.invOwner);
        }
 
        // Token: 0x0600416D RID: 16749 RVA: 0x0015136C File Offset: 0x0014F56C
        public bool Process(bool startTransaction = false)
        {
            InvOwner.Transaction.error = new InvOwner.ErrorMessage
            {
                card = this.thing
            };
            if (!this.IsValid())
            {
                SE.Play(InvOwner.Transaction.error.sound);
                if (!InvOwner.Transaction.error.lang.IsEmpty())
                {
                    Msg.Say(InvOwner.Transaction.error.lang, InvOwner.Transaction.error.card, null, null, null);
                }
                return false;
            }
            if (this.inv.IsFailByCurse(this.thing))
            {
                return false;
            }
            if (this.destInv.CopyOnTransfer)
            {
                int num = this.thing.Num;
                if (this.from != null && !(this.from.invOwner is InvOwnerAlly))
                {
                    this.thing = this.from.invOwner.PutBack(this.from);
                }
                else if (this.thing.parent != this.inv.Container)
                {
                    this.thing = this.inv.Container.AddThing(this.thing, true, -1, -1);
                }
                if (num != this.thing.Num)
                {
                    this.thing = this.thing.Split(num);
                    this.thing = EClass.pc.Pick(this.thing, false, false);
                }
                if (this.destInv.SingleTarget)
                {
                    this.thing = this.thing.Split(1);
                }
                if (this.to != null)
                {
                    this.to.button.SetCardGrid(this.thing, this.to.button.invOwner);
                }
                else
                {
                    int currentIndex = LayerDragGrid.Instance.currentIndex;
                    this.destInv.buttons[currentIndex].SetCardGrid(this.thing, this.destInv.buttons[currentIndex].invOwner);
                }
                this.destInv.OnProcess(this.thing);
                if (this.GetPrice() != 0)
                {
                    SE.Play("buy");
                    EClass.pc.ModCurrency(this.GetPrice() * -1, this.IDCurrency);
                }
                return true;
            }
            if (!startTransaction && this.to == null && (this.destInv.owner.IsPC ? EClass.pc : this.destInv.Container).things.IsFull(this.thing, true, true))
            {
                if (this.destInv.owner == EClass.pc)
                {
                    InvOwner.Transaction.error.Set("backpack_full", null, "beep_small");
                }
                SE.Beep();
                return false;
            }
            Thing thing = this.thing.parent as Thing;
            if (thing != null && thing.isNPCProperty)
            {
                Msg.Say("steal_container", thing, this.thing, null, null);
                this.thing.isNPCProperty = false;
                EClass.player.ModKarma(-1);
                EClass.pc.pos.TryWitnessCrime(EClass.pc, null, 4, null);
            }
            DragItemCard dragItemCard = new DragItemCard(this.button, startTransaction);
            Thing thing2 = this.thing.Split(this.num);
            bool flag = false;
            if (this.FreeTrade)
            {
                flag = true;
            }
            else
            {
                SE.Play(this.sell ? "sell" : "buy");
                int price = this.GetPrice();
                if (InvOwner.Trader.UseHomeResource)
                {
                    InvOwner.Trader.homeResource.Mod(this.sell ? price : (-price), true);
                }
                else
                {
                    if (this.sell)
                    {
                        EClass.pc.ModCurrency(price, this.IDCurrency);
                    }
                    else
                    {
                        EClass.pc.ModCurrency(-price, this.IDCurrency);
                    }
                    ShopTransaction.current.Process(thing2, thing2.Num, this.sell);
                    Msg.Say(this.sell ? "sold" : "bought", thing2, Lang._currency(Mathf.Abs(price), this.IDCurrency), null, null);
                    if (thing2.id == "statue_weird" && this.sell)
                    {
                        EClass.pc.Say("statue_install", null, null);
                    }
                }
            }
            if (this.destInv.Container.isChara && !this.destInv.owner.IsPC && !this.destInv.owner.Chara.CanAcceptItem(thing2, -1))
            {
                this.destInv.owner.Chara.Talk("tooHeavy", null, null, false);
                return false;
            }
            if (thing2.c_isImportant && !this.destInv.owner.IsPC && this.destInv.DenyImportant)
            {
                Msg.Say("markedImportant");
                return false;
            }
            if (this.inv.owner.isChara && this.inv.owner.Chara.IsPCFaction && !this.inv.owner.IsPC && thing2.IsRangedWeapon)
            {
                thing2.ammoData = null;
                thing2.c_ammo = 0;
            }
            if (startTransaction)
            {
                dragItemCard.from.thing = thing2;
                EClass.ui.StartDrag(dragItemCard);
            }
            else
            {
                Thing thing3;
                if (this.to != null)
                {
                    thing2.invY = this.to.invY;
                    thing3 = this.to.container.AddThing(thing2, true, this.to.invX, this.to.invY);
                    if (thing3 == thing2)
                    {
                        if (this.to.thing != null)
                        {
                            if (this.FreeTrade && !this.destInv.IsMagicChest)
                            {
                                EClass.ui.nextDrag = new DragItemCard(this.to.button, true);
                                this.to.invOwner.Grab(this.to);
                                flag = false;
                            }
                            else if (this.destInv.Container != thing2.parent)
                            {
                                thing3 = this.destInv.Container.AddThing(thing2, true, -1, -1);
                            }
                        }
                        this.to.grid[this.to.invX] = thing2;
                        thing2.invX = this.to.invX;
                        this.to.button.card = thing2;
                    }
                }
                else
                {
                    bool useGrid = EClass.game.UseGrid;
                    if (!EClass.game.UseGrid && this.destUIInv)
                    {
                        RectTransform rectTransform = new GameObject().AddComponent<RectTransform>();
                        rectTransform.SetParent(this.destUIInv.list.transform);
                        rectTransform.SetAnchor(0f, 0f, 0f, 0f);
                        rectTransform.localScale = Vector3.one;
                        rectTransform.sizeDelta = Vector3.one;
                        rectTransform.position = Input.mousePosition;
                        this.from.thing.posInvX = (int)rectTransform.anchoredPosition.x;
                        this.from.thing.posInvY = (int)rectTransform.anchoredPosition.y;
                    }
                    if (this.destInv.owner.IsPC)
                    {
                        thing3 = EClass.pc.Pick(thing2, false, true);
                    }
                    else
                    {
                        thing3 = this.destInv.Container.AddThing(thing2, useGrid, -1, -1);
                    }
                }
                this.destInv.OnProcess(thing3);
            }
            if (this.destInv.Container.trait is TraitDeliveryChest)
            {
                thing2.SetInt(102, EClass._zone.uid);
            }
            else
            {
                thing2.SetInt(102, 0);
            }
            Chara chara = this.destInv.Container.Chara;
            if (chara != null && !chara.IsPC)
            {
                chara.TryEquip(thing2, false);
                if (thing2.id == "lovepotion" || thing2.id == "dreambug")
                {
                    EClass.pc.GiveLovePotion(chara, thing2);
                    EClass.ui.CloseLayers();
                    return true;
                }
            }
            if (thing2.id == "statue_weird")
            {
                if (!this.destInv.owner.IsPC)
                {
                    EClass.pc.Say("statue_sell", null, null);
                }
                else if (thing == null || thing.GetRootCard() != EClass.pc)
                {
                    EClass.pc.Say("statue_pick", null, null);
                }
            }
            if (flag)
            {
                SE.Drop();
            }
            return true;
        }
 
        // Token: 0x0600416E RID: 16750 RVA: 0x00151B8D File Offset: 0x0014FD8D
        public int GetPrice()
        {
            if (InvOwner.Trader != null)
            {
                return InvOwner.Trader.GetPrice(this.thing, this.currency, this.num, this.sell);
            }
            return 0;
        }
 
        // Token: 0x0600416F RID: 16751 RVA: 0x00151BBC File Offset: 0x0014FDBC
        public bool IsValid()
        {
            if (this.destInv is InvOwnerToolbelt)
            {
                return false;
            }
            if (this.destInv.UseGuide && !this.destInv.ShouldShowGuide(this.thing))
            {
                return false;
            }
            if (this.destInv.Container.c_lockLv != 0)
            {
                return false;
            }
            if (this.thing.trait is TraitAbility && this.destInv.owner != EClass.pc)
            {
                return false;
            }
            if (this.destInv.CopyOnTransfer && this.to != null && this.to.button.index != LayerDragGrid.Instance.currentIndex)
            {
                return false;
            }
            if (!this.destInv.AllowTransfer)
            {
                return false;
            }
            if (this.thing.trait.IsContainer && this.destInv.Container != EClass.pc && !(this.destInv.Container.trait is TraitToolBelt) && this.thing.things.Count > 0 && (!this.destInv.CopyOnTransfer || !this.destInv.ShouldShowGuide(this.thing)) && (this.destInv != InvOwner.Trader || ShopTransaction.current == null || !ShopTransaction.current.HasBought(this.thing)))
            {
                InvOwner.Transaction.error.Set("errorUnemptyContainer", null, "beep_small");
                return false;
            }
            if (InvOwner.HasTrader && InvOwner.Trader.currency != CurrencyType.None)
            {
                int price = this.GetPrice();
                if (this.sell)
                {
                    if (this.destInv.destInvY == 0 && this.destInv.Container.things.IsFull(this.thing, true, true))
                    {
                        return false;
                    }
                    if (this.thing.c_isImportant)
                    {
                        return false;
                    }
                    if (ShopTransaction.current == null || !ShopTransaction.current.CanSellBack(this.thing, -1))
                    {
                        if (!InvOwner.Trader.AllowSell)
                        {
                            return false;
                        }
                        if (!this.FreeTrade && price == 0)
                        {
                            return false;
                        }
                    }
                }
                else if (!this.FreeTrade)
                {
                    if (InvOwner.Trader.UseHomeResource)
                    {
                        if (InvOwner.Trader.homeResource.value < price)
                        {
                            return false;
                        }
                    }
                    else if (EClass.pc.GetCurrency(this.IDCurrency) < price)
                    {
                        return false;
                    }
                }
            }
            if (this.to != null)
            {
                if (this.to.invOwner.IsMagicChest && this.to.container.things.IsFull(0))
                {
                    return false;
                }
                if (this.to.thing != null && !this.to.thing.isDestroyed && !this.destInv.AllowHold(this.to.thing))
                {
                    return false;
                }
            }
            if (this.destInv.owner.IsPC && !this.destInv.Container.IsPC && this.destInv.IsWeightOver(this.thing))
            {
                InvOwner.Transaction.error.Set("errorOverweight", null, "beep_small");
                return false;
            }
            return true;
        }
 
        // Token: 0x06004170 RID: 16752 RVA: 0x00151EBC File Offset: 0x001500BC
        public string GetTextDetail()
        {
            if (this.FreeTrade || (this.destInv.UseGuide && !this.destInv.ShouldShowGuide(this.thing)))
            {
                return "";
            }
            return this.destInv.GetTextDetail(this.thing, this.currency, this.num, this.sell);
        }
 
        // Token: 0x04002B37 RID: 11063
        public static InvOwner.ErrorMessage error = new InvOwner.ErrorMessage();
 
        // Token: 0x04002B38 RID: 11064
        public Thing thing;
 
        // Token: 0x04002B39 RID: 11065
        public ButtonGrid button;
 
        // Token: 0x04002B3A RID: 11066
        public int num = 1;
 
        // Token: 0x04002B3B RID: 11067
        public DragItemCard.DragInfo from;
 
        // Token: 0x04002B3C RID: 11068
        public DragItemCard.DragInfo to;
 
        // Token: 0x04002B3D RID: 11069
        public UIInventory destUIInv;
 
        // Token: 0x04002B3E RID: 11070
        public InvOwner inv;
    }
 
    // Token: 0x02000A98 RID: 2712
    public class Interaction
    {
        // Token: 0x04002B3F RID: 11071
        public string name;
 
        // Token: 0x04002B40 RID: 11072
        public Action action;
 
        // Token: 0x04002B41 RID: 11073
        public int priority;
 
        // Token: 0x04002B42 RID: 11074
        public bool repeatable;
    }
 
    // Token: 0x02000A99 RID: 2713
    public class ListInteraction : List<InvOwner.Interaction>
    {
        // Token: 0x06004173 RID: 16755 RVA: 0x00151F30 File Offset: 0x00150130
        public InvOwner.Interaction Add(string s, int priority, Action action)
        {
            InvOwner.Interaction interaction = new InvOwner.Interaction
            {
                name = s,
                priority = priority,
                action = action
            };
            base.Add(interaction);
            return interaction;
        }
 
        // Token: 0x06004174 RID: 16756 RVA: 0x00151F60 File Offset: 0x00150160
        public bool Contains(string s)
        {
            using (List<InvOwner.Interaction>.Enumerator enumerator = base.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if (enumerator.Current.name == s)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }
}