ThingContainer.cs

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using Newtonsoft.Json;
using UnityEngine;
 
// Token: 0x020004E9 RID: 1257
public class ThingContainer : List<Thing>
{
    // Token: 0x17000AE7 RID: 2791
    // (get) Token: 0x06002162 RID: 8546 RVA: 0x000B8583 File Offset: 0x000B6783
    [JsonIgnore]
    public int GridSize
    {
        get
        {
            return this.width * this.height;
        }
    }
 
    // Token: 0x17000AE8 RID: 2792
    // (get) Token: 0x06002163 RID: 8547 RVA: 0x000B8592 File Offset: 0x000B6792
    [JsonIgnore]
    public bool HasGrid
    {
        get
        {
            return this.grid != null;
        }
    }
 
    // Token: 0x17000AE9 RID: 2793
    // (get) Token: 0x06002164 RID: 8548 RVA: 0x000B859D File Offset: 0x000B679D
    [JsonIgnore]
    public bool IsMagicChest
    {
        get
        {
            return this.owner.trait is TraitMagicChest;
        }
    }
 
    // Token: 0x17000AEA RID: 2794
    // (get) Token: 0x06002165 RID: 8549 RVA: 0x000B85B2 File Offset: 0x000B67B2
    [JsonIgnore]
    public int MaxCapacity
    {
        get
        {
            if (!this.IsMagicChest)
            {
                return this.GridSize;
            }
            return 100 + this.owner.c_containerUpgrade.cap;
        }
    }
 
    // Token: 0x06002166 RID: 8550 RVA: 0x000B85D6 File Offset: 0x000B67D6
    public void SetOwner(Card owner)
    {
        this.owner = owner;
        this.width = owner.c_containerSize / 100;
        this.height = owner.c_containerSize % 100;
        if (this.width == 0)
        {
            this.width = 8;
            this.height = 5;
        }
    }
 
    // Token: 0x06002167 RID: 8551 RVA: 0x000B8614 File Offset: 0x000B6814
    public void ChangeSize(int w, int h)
    {
        this.width = w;
        this.height = h;
        this.owner.c_containerSize = w * 100 + h;
        this.RefreshGrid();
        Debug.Log(string.Concat(new string[]
        {
            base.Count.ToString(),
            "/",
            this.width.ToString(),
            "/",
            this.height.ToString(),
            "/",
            this.GridSize.ToString()
        }));
    }
 
    // Token: 0x06002168 RID: 8552 RVA: 0x000B86AC File Offset: 0x000B68AC
    public void RefreshGridRecursive()
    {
        foreach (Thing thing in this)
        {
            if (thing.IsContainer)
            {
                thing.things.RefreshGridRecursive();
            }
        }
        this.RefreshGrid();
    }
 
    // Token: 0x06002169 RID: 8553 RVA: 0x000B870C File Offset: 0x000B690C
    public void RefreshGrid()
    {
        if (this.GridSize == 0)
        {
            return;
        }
        this.grid = new List<Thing>(new Thing[this.GridSize]);
        foreach (Thing thing in this)
        {
            if (this.ShouldShowOnGrid(thing))
            {
                if (thing.invX >= this.GridSize || thing.invX < 0 || this.grid[thing.invX] != null)
                {
                    ThingContainer.listUnassigned.Add(thing);
                }
                else
                {
                    this.grid[thing.invX] = thing;
                }
            }
        }
        foreach (Thing thing2 in ThingContainer.listUnassigned)
        {
            int freeGridIndex = this.GetFreeGridIndex();
            if (freeGridIndex == -1)
            {
                break;
            }
            this.grid[freeGridIndex] = thing2;
            thing2.invX = freeGridIndex;
        }
        ThingContainer.listUnassigned.Clear();
    }
 
    // Token: 0x0600216A RID: 8554 RVA: 0x000B882C File Offset: 0x000B6A2C
    public void RefreshGrid(UIMagicChest magic, Window.SaveData data)
    {
        magic.filteredList.Clear();
        magic.cats.Clear();
        magic.catCount.Clear();
        this.grid = new List<Thing>(new Thing[this.GridSize]);
        string lastSearch = magic.lastSearch;
        bool flag = !lastSearch.IsEmpty();
        bool flag2 = !magic.idCat.IsEmpty();
        Window.SaveData.CategoryType category = data.category;
        bool flag3 = category != Window.SaveData.CategoryType.None;
        string text = "";
        foreach (Thing thing in this)
        {
            if (flag3)
            {
                switch (category)
                {
                case Window.SaveData.CategoryType.Main:
                    text = thing.category.GetRoot().id;
                    break;
                case Window.SaveData.CategoryType.Sub:
                    text = thing.category.GetSecondRoot().id;
                    break;
                case Window.SaveData.CategoryType.Exact:
                    text = thing.category.id;
                    break;
                }
                magic.cats.Add(text);
                if (magic.catCount.ContainsKey(text))
                {
                    Dictionary<string, int> catCount = magic.catCount;
                    string key = text;
                    int num = catCount[key];
                    catCount[key] = num + 1;
                }
                else
                {
                    magic.catCount.Add(text, 1);
                }
            }
            if (flag)
            {
                if (thing.tempName == null)
                {
                    thing.tempName = thing.GetName(NameStyle.Full, 1).ToLower();
                }
                if (!thing.tempName.Contains(lastSearch) && !thing.source.GetSearchName(false).Contains(lastSearch) && !thing.source.GetSearchName(true).Contains(lastSearch))
                {
                    continue;
                }
            }
            if (!flag2 || !(text != magic.idCat))
            {
                magic.filteredList.Add(thing);
            }
        }
        if (flag2 && !magic.cats.Contains(magic.idCat))
        {
            magic.idCat = "";
            this.RefreshGrid(magic, data);
            return;
        }
        magic.pageMax = (magic.filteredList.Count - 1) / this.GridSize;
        if (magic.page > magic.pageMax)
        {
            magic.page = magic.pageMax;
        }
        for (int i = 0; i < this.GridSize; i++)
        {
            int num2 = magic.page * this.GridSize + i;
            if (num2 >= magic.filteredList.Count)
            {
                break;
            }
            Thing thing2 = magic.filteredList[num2];
            this.grid[i] = thing2;
            thing2.invX = i;
        }
        magic.RefreshCats();
    }
 
    // Token: 0x0600216B RID: 8555 RVA: 0x000B8AD0 File Offset: 0x000B6CD0
    public bool IsOccupied(int x, int y)
    {
        foreach (Thing thing in this)
        {
            if (thing.invY == y && thing.invX == x)
            {
                return true;
            }
        }
        return false;
    }
 
    // Token: 0x0600216C RID: 8556 RVA: 0x000B8B30 File Offset: 0x000B6D30
    public bool ShouldShowOnGrid(Thing t)
    {
        if (!this.owner.IsPC)
        {
            return !(t.trait is TraitChestMerchant);
        }
        return !t.isEquipped && !t.IsHotItem;
    }
 
    // Token: 0x0600216D RID: 8557 RVA: 0x000B8B64 File Offset: 0x000B6D64
    public void OnAdd(Thing t)
    {
        if (!this.HasGrid)
        {
            return;
        }
        if (!this.ShouldShowOnGrid(t))
        {
            return;
        }
        int freeGridIndex = this.GetFreeGridIndex();
        if (freeGridIndex != -1)
        {
            this.grid[freeGridIndex] = t;
        }
        t.pos.x = freeGridIndex;
    }
 
    // Token: 0x0600216E RID: 8558 RVA: 0x000B8BA8 File Offset: 0x000B6DA8
    public bool IsFull(int y = 0)
    {
        if (this.IsMagicChest)
        {
            return base.Count >= this.MaxCapacity || (this.owner.trait.IsFridge && !this.owner.isOn);
        }
        if (y != 0)
        {
            return false;
        }
        if (this.owner.trait.IsSpecialContainer && this.owner.parent != null)
        {
            return true;
        }
        if (!this.HasGrid)
        {
            return base.Count >= this.GridSize;
        }
        return this.GetFreeGridIndex() == -1;
    }
 
    // Token: 0x0600216F RID: 8559 RVA: 0x000B8C3C File Offset: 0x000B6E3C
    public bool IsOverflowing()
    {
        if (!this.HasGrid || this.IsMagicChest)
        {
            return false;
        }
        int num = 0;
        foreach (Thing thing in this)
        {
            if (thing.invY != 1 && !thing.isEquipped)
            {
                num++;
            }
        }
        return num > this.grid.Count;
    }
 
    // Token: 0x06002170 RID: 8560 RVA: 0x000B8CC0 File Offset: 0x000B6EC0
    public int GetFreeGridIndex()
    {
        for (int i = 0; i < this.grid.Count; i++)
        {
            if (this.grid[i] == null)
            {
                return i;
            }
        }
        return -1;
    }
 
    // Token: 0x06002171 RID: 8561 RVA: 0x000B8CF4 File Offset: 0x000B6EF4
    public void OnRemove(Thing t)
    {
        if (!this.HasGrid || t.invY != 0)
        {
            return;
        }
        int num = this.grid.IndexOf(t);
        if (num != -1)
        {
            this.grid[num] = null;
        }
    }
 
    // Token: 0x06002172 RID: 8562 RVA: 0x000B8D30 File Offset: 0x000B6F30
    public void SetSize(int w, int h)
    {
        this.owner.c_containerSize = w * 100 + h;
        this.SetOwner(this.owner);
    }
 
    // Token: 0x06002173 RID: 8563 RVA: 0x000B8D50 File Offset: 0x000B6F50
    public Thing TryStack(Thing target, int destInvX = -1, int destInvY = -1)
    {
        foreach (Thing thing in this)
        {
            if (destInvX == -1 && thing.CanSearchContents)
            {
                Thing thing2 = thing.things.TryStack(target, destInvX, destInvY);
                if (thing2 != target)
                {
                    return thing2;
                }
            }
            if ((destInvX == -1 || (thing.invX == destInvX && thing.invY == destInvY)) && thing != target && target.TryStackTo(thing))
            {
                return thing;
            }
        }
        return target;
    }
 
    // Token: 0x06002174 RID: 8564 RVA: 0x000B8DE4 File Offset: 0x000B6FE4
    public Thing CanStack(Thing target, int destInvX = -1, int destInvY = -1)
    {
        foreach (Thing thing in this)
        {
            if (thing != target && target.CanStackTo(thing))
            {
                return thing;
            }
        }
        return target;
    }
 
    // Token: 0x06002175 RID: 8565 RVA: 0x000B8E40 File Offset: 0x000B7040
    public ThingContainer.DestData GetDest(Thing t, bool tryStack = true)
    {
        ThingContainer.<>c__DisplayClass31_0 CS$<>8__locals1;
        CS$<>8__locals1.t = t;
        CS$<>8__locals1.tryStack = tryStack;
        CS$<>8__locals1.<>4__this = this;
        CS$<>8__locals1.d = default(ThingContainer.DestData);
        if (!this.owner.IsPC)
        {
            this.<GetDest>g__SearchDest|31_0(this, true, true, ref CS$<>8__locals1);
            return CS$<>8__locals1.d;
        }
        CS$<>8__locals1.flag = CS$<>8__locals1.t.category.GetRoot().id.ToEnum(true);
        if (CS$<>8__locals1.flag == ContainerFlag.none)
        {
            CS$<>8__locals1.flag = ContainerFlag.other;
        }
        ThingContainer._listContainers.Clear();
        ThingContainer._listContainers.Add(this);
        this.<GetDest>g__TrySearchContainer|31_1(this.owner, ref CS$<>8__locals1);
        ThingContainer._listContainers.Sort(delegate(ThingContainer a, ThingContainer b)
        {
            Window.SaveData windowSaveData = b.owner.GetWindowSaveData();
            int num = ((windowSaveData != null) ? windowSaveData.priority : 0) * 10 + (b.owner.IsPC ? 1 : 0);
            Window.SaveData windowSaveData2 = a.owner.GetWindowSaveData();
            return num - (((windowSaveData2 != null) ? windowSaveData2.priority : 0) * 10 + (a.owner.IsPC ? 1 : 0));
        });
        foreach (ThingContainer things in ThingContainer._listContainers)
        {
            this.<GetDest>g__SearchDest|31_0(things, false, true, ref CS$<>8__locals1);
            if (CS$<>8__locals1.d.IsValid)
            {
                return CS$<>8__locals1.d;
            }
        }
        foreach (ThingContainer things2 in ThingContainer._listContainers)
        {
            this.<GetDest>g__SearchDest|31_0(things2, true, false, ref CS$<>8__locals1);
            if (CS$<>8__locals1.d.IsValid)
            {
                return CS$<>8__locals1.d;
            }
        }
        return CS$<>8__locals1.d;
    }
 
    // Token: 0x06002176 RID: 8566 RVA: 0x000B8FDC File Offset: 0x000B71DC
    public bool IsFull(Thing t, bool recursive = true, bool tryStack = true)
    {
        return this.IsFull(0) && (!tryStack || this.CanStack(t, -1, -1) == t) && (!recursive || !this.GetDest(t, tryStack).IsValid);
    }
 
    // Token: 0x06002177 RID: 8567 RVA: 0x000B901C File Offset: 0x000B721C
    public void AddCurrency(Card owner, string id, int a, SourceMaterial.Row mat = null)
    {
        int num = a;
        this.ListCurrency(id);
        foreach (Thing thing in ThingContainer.tempList)
        {
            if (!(thing.id != id) && (mat == null || thing.material == mat))
            {
                if (num > 0)
                {
                    thing.ModNum(num, true);
                    return;
                }
                if (thing.Num + num >= 0)
                {
                    thing.ModNum(num, true);
                    return;
                }
                num += thing.Num;
                thing.ModNum(-thing.Num, true);
            }
        }
        if (num == 0)
        {
            return;
        }
        if (num > 0)
        {
            Thing thing2 = ThingGen.Create(id, -1, -1);
            if (mat != null)
            {
                thing2.ChangeMaterial(mat);
            }
            owner.AddThing(thing2, true, -1, -1).SetNum(num);
            return;
        }
    }
 
    // Token: 0x06002178 RID: 8568 RVA: 0x000B90F8 File Offset: 0x000B72F8
    public void DestroyAll(Func<Thing, bool> funcExclude = null)
    {
        this.ForeachReverse(delegate(Thing t)
        {
            if (funcExclude != null && funcExclude(t))
            {
                return;
            }
            t.Destroy();
            this.Remove(t);
        });
        if (this.grid != null)
        {
            for (int i = 0; i < this.grid.Count; i++)
            {
                this.grid[i] = null;
            }
        }
    }
 
    // Token: 0x06002179 RID: 8569 RVA: 0x000B9158 File Offset: 0x000B7358
    public Thing Find(int uid)
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                Thing thing2 = thing.things.Find(uid);
                if (thing2 != null)
                {
                    return thing2;
                }
            }
            if (thing.uid == uid)
            {
                return thing;
            }
        }
        return null;
    }
 
    // Token: 0x0600217A RID: 8570 RVA: 0x000B91CC File Offset: 0x000B73CC
    public Thing Find<T>() where T : Trait
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                Thing thing2 = thing.things.Find<T>();
                if (thing2 != null)
                {
                    return thing2;
                }
            }
            if (thing.trait is T)
            {
                return thing;
            }
        }
        return null;
    }
 
    // Token: 0x0600217B RID: 8571 RVA: 0x000B9244 File Offset: 0x000B7444
    public Thing Find(Func<Thing, bool> func, bool recursive = true)
    {
        foreach (Thing thing in this)
        {
            if (recursive && thing.CanSearchContents)
            {
                Thing thing2 = thing.things.Find(func, true);
                if (thing2 != null)
                {
                    return thing2;
                }
            }
            if (func(thing))
            {
                return thing;
            }
        }
        return null;
    }
 
    // Token: 0x0600217C RID: 8572 RVA: 0x000B92BC File Offset: 0x000B74BC
    public Thing Find(string id, string idMat)
    {
        return this.Find(id, idMat.IsEmpty() ? -1 : EClass.sources.materials.alias[idMat].id, -1);
    }
 
    // Token: 0x0600217D RID: 8573 RVA: 0x000B92EC File Offset: 0x000B74EC
    public Thing Find(string id, int idMat = -1, int refVal = -1)
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                Thing thing2 = thing.things.Find(id, idMat, refVal);
                if (thing2 != null)
                {
                    return thing2;
                }
            }
            if (thing.id == id && (idMat == -1 || thing.material.id == idMat) && (refVal == -1 || thing.refVal == refVal))
            {
                return thing;
            }
        }
        return null;
    }
 
    // Token: 0x0600217E RID: 8574 RVA: 0x000B9388 File Offset: 0x000B7588
    public Thing FindStealable()
    {
        List<Thing> list = new List<Thing>();
        foreach (Thing thing in this)
        {
            if (!thing.IsContainer && thing.trait.CanBeStolen)
            {
                list.Add(thing);
            }
        }
        if (list.Count == 0)
        {
            return null;
        }
        list.Sort((Thing a, Thing b) => ThingContainer.<FindStealable>g__Compare|40_0(a) - ThingContainer.<FindStealable>g__Compare|40_0(b));
        return list[0];
    }
 
    // Token: 0x0600217F RID: 8575 RVA: 0x000B9428 File Offset: 0x000B7628
    public ThingStack GetThingStack(string id, int refVal = -1)
    {
        ThingStack s = new ThingStack();
        bool isOrigin = EClass.sources.cards.map[id].isOrigin;
        return this.GetThingStack(id, s, isOrigin, refVal);
    }
 
    // Token: 0x06002180 RID: 8576 RVA: 0x000B9460 File Offset: 0x000B7660
    public ThingStack GetThingStack(string id, ThingStack s, bool isOrigin, int refVal = -1)
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                thing.things.GetThingStack(id, s, isOrigin, refVal);
            }
            if ((refVal == -1 || thing.refVal == refVal) && thing.IsIdentified && (thing.id == id || (isOrigin && thing.source._origin == id)))
            {
                s.Add(thing);
            }
        }
        return s;
    }
 
    // Token: 0x06002181 RID: 8577 RVA: 0x000B9504 File Offset: 0x000B7704
    public ThingStack GetThingStack(string id)
    {
        ThingStack s = new ThingStack();
        bool isOrigin = EClass.sources.cards.map[id].isOrigin;
        return this.GetThingStack(id, s, isOrigin);
    }
 
    // Token: 0x06002182 RID: 8578 RVA: 0x000B953C File Offset: 0x000B773C
    public ThingStack GetThingStack(string id, ThingStack s, bool isOrigin)
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                thing.things.GetThingStack(id, s, isOrigin);
            }
            if (thing.id == id || (isOrigin && thing.source._origin == id))
            {
                s.Add(thing);
            }
        }
        return s;
    }
 
    // Token: 0x06002183 RID: 8579 RVA: 0x000B95C8 File Offset: 0x000B77C8
    public int GetCurrency(string id, ref int sum, SourceMaterial.Row mat = null)
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                thing.things.GetCurrency(id, ref sum, mat);
            }
            if (thing.id == id && (mat == null || thing.material == mat))
            {
                sum += thing.Num;
            }
        }
        return sum;
    }
 
    // Token: 0x06002184 RID: 8580 RVA: 0x000B9650 File Offset: 0x000B7850
    public List<Thing> ListCurrency(string id)
    {
        ThingContainer.tempList.Clear();
        this._ListCurrency(id);
        return ThingContainer.tempList;
    }
 
    // Token: 0x06002185 RID: 8581 RVA: 0x000B9668 File Offset: 0x000B7868
    private void _ListCurrency(string id)
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                thing.things._ListCurrency(id);
            }
            if (thing.id == id)
            {
                ThingContainer.tempList.Add(thing);
            }
        }
    }
 
    // Token: 0x06002186 RID: 8582 RVA: 0x000B96DC File Offset: 0x000B78DC
    public List<Thing> List(Func<Thing, bool> func, bool onlyAccessible = false)
    {
        ThingContainer.tempList.Clear();
        this._List(func, onlyAccessible);
        return ThingContainer.tempList;
    }
 
    // Token: 0x06002187 RID: 8583 RVA: 0x000B96F8 File Offset: 0x000B78F8
    public void _List(Func<Thing, bool> func, bool onlyAccessible = false)
    {
        foreach (Thing thing in this)
        {
            if (!onlyAccessible || !(thing.parent is Card) || (thing.parent as Card).c_lockLv <= 0)
            {
                thing.things._List(func, onlyAccessible);
                if (func(thing))
                {
                    ThingContainer.tempList.Add(thing);
                }
            }
        }
    }
 
    // Token: 0x06002188 RID: 8584 RVA: 0x000B9784 File Offset: 0x000B7984
    public void AddFactory(HashSet<string> hash)
    {
        foreach (Thing thing in this)
        {
            if (thing.CanSearchContents)
            {
                thing.things.AddFactory(hash);
            }
            if (thing.trait.IsFactory)
            {
                hash.Add(thing.id);
            }
            if (thing.trait.ToggleType == ToggleType.Fire && thing.isOn)
            {
                hash.Add("fire");
            }
        }
    }
 
    // Token: 0x06002189 RID: 8585 RVA: 0x000B981C File Offset: 0x000B7A1C
    public void Foreach(Action<Thing> action, bool onlyAccessible = true)
    {
        foreach (Thing thing in this)
        {
            if (!onlyAccessible || thing.CanSearchContents)
            {
                thing.things.Foreach(action, true);
            }
            action(thing);
        }
    }
 
    // Token: 0x0600218A RID: 8586 RVA: 0x000B9884 File Offset: 0x000B7A84
    public void Foreach(Func<Thing, bool> action, bool onlyAccessible = true)
    {
        foreach (Thing thing in this)
        {
            if (!onlyAccessible || thing.CanSearchContents)
            {
                thing.things.Foreach(action, true);
            }
            if (action(thing))
            {
                break;
            }
        }
    }
 
    // Token: 0x0600218D RID: 8589 RVA: 0x000B9918 File Offset: 0x000B7B18
    [CompilerGenerated]
    private void <GetDest>g__SearchDest|31_0(ThingContainer things, bool searchEmpty, bool searchStack, ref ThingContainer.<>c__DisplayClass31_0 A_4)
    {
        if (A_4.t.IsContainer && A_4.t.things.Count > 0 && things.owner.IsContainer && !(things.owner.trait is TraitToolBelt))
        {
            return;
        }
        if (searchStack && A_4.tryStack)
        {
            Thing thing = things.CanStack(A_4.t, -1, -1);
            if (thing != A_4.t)
            {
                A_4.d.stack = thing;
                return;
            }
        }
        if (searchEmpty && !things.IsFull(0))
        {
            if (things.owner.trait is TraitToolBelt)
            {
                return;
            }
            if (!things.owner.isChara && !(things.owner.parent is Chara))
            {
                Thing thing2 = things.owner.parent as Thing;
                if (!(((thing2 != null) ? thing2.trait : null) is TraitToolBelt))
                {
                    return;
                }
            }
            A_4.d.container = things.owner;
        }
    }
 
    // Token: 0x0600218E RID: 8590 RVA: 0x000B9A10 File Offset: 0x000B7C10
    [CompilerGenerated]
    private void <GetDest>g__TrySearchContainer|31_1(Card c, ref ThingContainer.<>c__DisplayClass31_0 A_2)
    {
        foreach (Thing thing in c.things)
        {
            if (thing.CanSearchContents)
            {
                this.<GetDest>g__TrySearchContainer|31_1(thing, ref A_2);
            }
        }
        if (c.things == this)
        {
            return;
        }
        Window.SaveData windowSaveData = c.GetWindowSaveData();
        if (windowSaveData != null)
        {
            if (windowSaveData.noRotten && A_2.t.IsDecayed)
            {
                return;
            }
            if (windowSaveData.onlyRottable && A_2.t.trait.Decay == 0)
            {
                return;
            }
            if (windowSaveData.advDistribution)
            {
                using (HashSet<int>.Enumerator enumerator2 = windowSaveData.cats.GetEnumerator())
                {
                    while (enumerator2.MoveNext())
                    {
                        int num = enumerator2.Current;
                        if (A_2.t.category.uid == num)
                        {
                            ThingContainer._listContainers.Add(c.things);
                            break;
                        }
                    }
                    return;
                }
            }
            if (!windowSaveData.flag.HasFlag(A_2.flag))
            {
                ThingContainer._listContainers.Add(c.things);
            }
        }
    }
 
    // Token: 0x0600218F RID: 8591 RVA: 0x000B9B4C File Offset: 0x000B7D4C
    [CompilerGenerated]
    internal static int <FindStealable>g__Compare|40_0(Thing a)
    {
        return a.SelfWeight + (a.isEquipped ? 10000 : 0);
    }
 
    // Token: 0x04001128 RID: 4392
    [JsonIgnore]
    public static List<Thing> listUnassigned = new List<Thing>();
 
    // Token: 0x04001129 RID: 4393
    [JsonIgnore]
    public const int InvYHotbar = 1;
 
    // Token: 0x0400112A RID: 4394
    [JsonIgnore]
    public int width;
 
    // Token: 0x0400112B RID: 4395
    [JsonIgnore]
    public int height;
 
    // Token: 0x0400112C RID: 4396
    [JsonIgnore]
    public Card owner;
 
    // Token: 0x0400112D RID: 4397
    [JsonIgnore]
    public List<Thing> grid;
 
    // Token: 0x0400112E RID: 4398
    private static List<ThingContainer> _listContainers = new List<ThingContainer>();
 
    // Token: 0x0400112F RID: 4399
    private static List<Thing> tempList = new List<Thing>();
 
    // Token: 0x020009E9 RID: 2537
    public struct DestData
    {
        // Token: 0x170011D7 RID: 4567
        // (get) Token: 0x06003F36 RID: 16182 RVA: 0x0014BBBE File Offset: 0x00149DBE
        public bool IsValid
        {
            get
            {
                return this.stack != null || this.container != null;
            }
        }
 
        // Token: 0x0400290F RID: 10511
        public Card container;
 
        // Token: 0x04002910 RID: 10512
        public Thing stack;
    }
}