LayerDragGrid.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x0200057B RID: 1403
public class LayerDragGrid : LayerBaseCraft
{
    // Token: 0x17000B88 RID: 2952
    // (get) Token: 0x06002656 RID: 9814 RVA: 0x000D828E File Offset: 0x000D648E
    public ButtonGrid CurrentButton
    {
        get
        {
            return this.buttons[this.currentIndex];
        }
    }
 
    // Token: 0x17000B89 RID: 2953
    // (get) Token: 0x06002657 RID: 9815 RVA: 0x000D82A1 File Offset: 0x000D64A1
    public override bool CanCancelAI
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x17000B8A RID: 2954
    // (get) Token: 0x06002658 RID: 9816 RVA: 0x000D82A4 File Offset: 0x000D64A4
    public override bool RepeatAI
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x06002659 RID: 9817 RVA: 0x000D82A7 File Offset: 0x000D64A7
    public void OnOpen()
    {
        LayerDragGrid.Instance = this;
        InvOwner.Trader = this.owner;
        this.wasInventoryOpen = ELayer.ui.IsInventoryOpen;
        if (!this.wasInventoryOpen)
        {
            ELayer.ui.OpenFloatInv(true);
        }
    }
 
    // Token: 0x0600265A RID: 9818 RVA: 0x000D82E0 File Offset: 0x000D64E0
    public LayerDragGrid SetInv(InvOwnerDraglet owner, bool refuelFromLayerDragGrid = false)
    {
        owner.Init();
        owner.owner.SetImage(this.imageOwner);
        this.owner = owner;
        this.textTitle.text = owner.langTransfer.lang();
        this.OnOpen();
        this.buttonOwner.SetCardGrid(owner.owner, null);
        owner.Container.things.RefreshGrid();
        for (int j = 0; j < this.buttons.Count; j++)
        {
            this.buttons[j].gameObject.AddComponent<CanvasGroup>();
            if (owner.numDragGrid > j)
            {
                this.buttons[j].SetCardGrid(null, owner);
                this.buttons[j].index = j;
                owner.buttons.Add(this.buttons[j]);
            }
            else
            {
                this.buttons[j].SetActive(false);
            }
        }
        this.textFuel.SetActive(owner.owner.trait.IsRequireFuel);
        owner.BuildUICurrency(this.uiCurrency, false);
        base.InvokeRepeating("RefreshCost", 0f, 0.2f);
        this.RebuildLayout(true);
        this.RefreshCurrentGrid();
        this.RefreshCost();
        this.RebuildLayout(true);
        this.buttonRefuel.SetActive(owner.ShowFuel);
        this.buttonAutoRefuel.SetActive(owner.ShowFuel);
        if (owner.CanTargetAlly && ELayer.pc.party.members.Count > 1)
        {
            BaseList baseList = this.listAlly;
            UIList.Callback<Chara, UIButton> callback = new UIList.Callback<Chara, UIButton>();
            callback.onInstantiate = delegate(Chara a, UIButton b)
            {
                a.SetImage(b.icon);
                b.SetTooltipLang(a.Name);
            };
            callback.onClick = delegate(Chara c, UIButton i)
            {
                if (LayerInventory.CloseAllyInv(c))
                {
                    return;
                }
                SE.PopInventory();
                LayerInventory.CreateContainerAlly(c, c);
            };
            callback.onSort = delegate(Chara a, UIList.SortMode m)
            {
                a.SetSortVal(m, CurrencyType.Money);
                return -a.sortVal;
            };
            callback.onList = delegate(UIList.SortMode m)
            {
                foreach (Chara chara in ELayer.pc.party.members)
                {
                    if (!chara.IsPC)
                    {
                        this.listAlly.Add(chara);
                    }
                }
            };
            baseList.callbacks = callback;
            this.listAlly.List(false);
        }
        else
        {
            this.listAlly.SetActive(false);
        }
        Action <>9__6;
        this.buttonRefuel.SetOnClick(delegate
        {
            this.windows[0].SetInteractable(false, 0f);
            this.info.InitFuel(owner.owner);
            Layer layer = LayerDragGrid.Create(new InvOwnerRefuel(owner.owner, null, CurrencyType.None), true);
            Action onKill;
            if ((onKill = <>9__6) == null)
            {
                onKill = (<>9__6 = delegate()
                {
                    if (!this.isDestroyed)
                    {
                        this.windows[0].SetInteractable(true, 0.5f);
                        this.info.Init(owner.owner);
                        this.OnOpen();
                        this.RefreshCurrentGrid();
                        this.Redraw();
                        owner.OnAfterRefuel();
                    }
                });
            }
            layer.SetOnKill(onKill);
        });
        this.buttonAutoRefuel.SetOnClick(delegate
        {
            SE.Click();
            owner.owner.autoRefuel = !owner.owner.autoRefuel;
            this.RefreshCost();
            if (owner.owner.trait.IsFuelEnough(1, null, true))
            {
                owner.OnAfterRefuel();
            }
        });
        try
        {
            if (owner is InvOwnerRefuel)
            {
                if (refuelFromLayerDragGrid)
                {
                    this.info.SetActive(false);
                }
                else
                {
                    Debug.Log(owner.owner);
                    this.info.InitFuel(owner.owner);
                }
            }
            else
            {
                this.info.Init(owner.owner);
            }
        }
        catch (Exception ex)
        {
            Debug.LogError(ex.Message);
        }
        return this;
    }
 
    // Token: 0x0600265B RID: 9819 RVA: 0x000D8624 File Offset: 0x000D6824
    public int GetPrice()
    {
        return this.owner.price;
    }
 
    // Token: 0x0600265C RID: 9820 RVA: 0x000D8634 File Offset: 0x000D6834
    public void RefreshCost()
    {
        this.buttonAutoRefuel.mainText.text = (this.owner.owner.autoRefuel ? "On" : "Off");
        this.buttonAutoRefuel.icon.SetAlpha(this.owner.owner.autoRefuel ? 1f : 0.4f);
        this.textFuel.text = ((int)((float)this.owner.owner.c_charges / (float)this.owner.owner.trait.MaxFuel * 100f)).ToString() + "%";
        int price = this.GetPrice();
        this.itemCost.transform.parent.SetActive(price != 0);
        if (price == 0)
        {
            return;
        }
        this.itemCost.text1.SetText(Lang._currency(this.GetPrice(), false, 14), (ELayer.pc.GetCurrency(this.owner.IDCurrency) >= price) ? FontColor.Good : FontColor.Bad);
        this.itemCost.image1.sprite = SpriteSheet.Get("icon_" + this.owner.IDCurrency);
    }
 
    // Token: 0x0600265D RID: 9821 RVA: 0x000D8774 File Offset: 0x000D6974
    public bool IsAllGridSet()
    {
        for (int i = 0; i < this.owner.numDragGrid; i++)
        {
            if (this.buttons[i].card == null)
            {
                return false;
            }
        }
        return true;
    }
 
    // Token: 0x0600265E RID: 9822 RVA: 0x000D87B0 File Offset: 0x000D69B0
    public override void ClearButtons()
    {
        for (int i = 0; i < this.owner.numDragGrid; i++)
        {
            this.buttons[i].SetCardGrid(null, null);
        }
        this.RefreshCurrentGrid();
    }
 
    // Token: 0x0600265F RID: 9823 RVA: 0x000D87EC File Offset: 0x000D69EC
    public override void RefreshCurrentGrid()
    {
        int num = -1;
        for (int i = 0; i < this.buttons.Count; i++)
        {
            bool flag = this.buttons[i].Card != null;
            if (num == -1 && (!flag || i == this.owner.numDragGrid - 1))
            {
                num = i;
            }
            this.buttons[i].interactable = (flag || num == i);
            this.buttons[i].GetComponent<CanvasGroup>().alpha = (this.buttons[i].interactable ? 1f : 0.5f);
        }
        this.currentIndex = num;
        bool flag2 = num >= 0 && num < this.owner.numDragGrid;
        if (flag2)
        {
            this.transIndex.position = this.buttons[num].transform.position;
        }
        this.transIndex.SetActive(flag2);
        this.Redraw();
    }
 
    // Token: 0x06002660 RID: 9824 RVA: 0x000D88E8 File Offset: 0x000D6AE8
    public override List<Thing> GetTargets()
    {
        List<Thing> list = new List<Thing>();
        TraitCrafter traitCrafter = this.owner.owner.trait as TraitCrafter;
        for (int i = 0; i < traitCrafter.numIng; i++)
        {
            Card card = this.buttons[i].card;
            list.Add(((card != null) ? card.Thing : null) ?? null);
        }
        return list;
    }
 
    // Token: 0x06002661 RID: 9825 RVA: 0x000D894C File Offset: 0x000D6B4C
    private void Update()
    {
        this.Validate();
    }
 
    // Token: 0x06002662 RID: 9826 RVA: 0x000D8954 File Offset: 0x000D6B54
    public void Validate()
    {
        Card card = this.buttonOwner.card;
        if (card.Num != this.lastNum)
        {
            this.lastNum = card.Num;
            this.buttonOwner.SetCardGrid(this.owner.owner, null);
        }
        if (card == null || card.isDestroyed)
        {
            this.Close();
        }
    }
 
    // Token: 0x06002663 RID: 9827 RVA: 0x000D89B0 File Offset: 0x000D6BB0
    public void Redraw()
    {
        foreach (ButtonGrid buttonGrid in this.buttons)
        {
            if (buttonGrid.gameObject.activeSelf)
            {
                buttonGrid.Redraw();
            }
        }
        LayerInventory.SetDirtyAll(true);
    }
 
    // Token: 0x06002664 RID: 9828 RVA: 0x000D8A18 File Offset: 0x000D6C18
    public override void OnKill()
    {
        LayerInventory.CloseAllyInv();
        InvOwner.Trader = null;
        if (!this.wasInventoryOpen && ELayer.ui.IsInventoryOpen)
        {
            ELayer.ui.ToggleInventory(false);
        }
        LayerInventory.SetDirtyAll(false);
        if (ELayer.pc.ai is AI_UseCrafter && ELayer.pc.ai.IsRunning)
        {
            ELayer.pc.ai.Cancel();
        }
    }
 
    // Token: 0x06002665 RID: 9829 RVA: 0x000D8A87 File Offset: 0x000D6C87
    public override void OnUpdateInput()
    {
        if (EInput.action == EAction.MenuInventory || Input.GetKeyDown(KeyCode.Tab))
        {
            this.Close();
            EInput.WaitReleaseKey();
            return;
        }
        base.OnUpdateInput();
    }
 
    // Token: 0x06002666 RID: 9830 RVA: 0x000D8AAD File Offset: 0x000D6CAD
    public override void OnRightClick()
    {
        if (InputModuleEX.GetComponentOf<ButtonGrid>() == null)
        {
            this.Close();
        }
    }
 
    // Token: 0x06002667 RID: 9831 RVA: 0x000D8AC2 File Offset: 0x000D6CC2
    public static LayerDragGrid Create(InvOwnerDraglet owner, bool refuelFromLayerDragGrid = false)
    {
        return ELayer.ui.AddLayer<LayerDragGrid>("LayerInventory/LayerDragGrid").SetInv(owner, refuelFromLayerDragGrid);
    }
 
    // Token: 0x06002668 RID: 9832 RVA: 0x000D8ADA File Offset: 0x000D6CDA
    public static LayerDragGrid CreateOffering(TraitAltar altar)
    {
        Msg.Say("offer_what");
        return LayerDragGrid.Create(new InvOwnerOffering(altar.owner, null, CurrencyType.Money)
        {
            altar = altar
        }, false);
    }
 
    // Token: 0x06002669 RID: 9833 RVA: 0x000D8B04 File Offset: 0x000D6D04
    public static LayerDragGrid CreateDeliver(InvOwnerDeliver.Mode mode = InvOwnerDeliver.Mode.Default, Card owner = null)
    {
        if (mode == InvOwnerDeliver.Mode.Tax)
        {
            Msg.Say("bills", ELayer.player.taxBills.ToString() ?? "", null, null, null);
        }
        Msg.Say("deliver_what");
        return LayerDragGrid.Create(new InvOwnerDeliver(owner, null, CurrencyType.Money)
        {
            mode = mode
        }, false);
    }
 
    // Token: 0x0600266A RID: 9834 RVA: 0x000D8B5B File Offset: 0x000D6D5B
    public static LayerDragGrid CreateGive(Chara c)
    {
        return LayerDragGrid.Create(new InvOwnerGive(c, null, CurrencyType.Money)
        {
            chara = c
        }, false);
    }
 
    // Token: 0x0600266B RID: 9835 RVA: 0x000D8B72 File Offset: 0x000D6D72
    public static LayerDragGrid CreateCraft(TraitCrafter crafter)
    {
        return LayerDragGrid.Create(new InvOwnerCraft(crafter.owner, null, CurrencyType.None)
        {
            crafter = crafter
        }, false);
    }
 
    // Token: 0x0600266C RID: 9836 RVA: 0x000D8B8E File Offset: 0x000D6D8E
    public static LayerDragGrid CreateRecycle(TraitRecycle recycle)
    {
        Msg.Say("recycle_what");
        return LayerDragGrid.Create(new InvOwnerRecycle(recycle.owner, null, CurrencyType.Ecopo)
        {
            recycle = recycle
        }, false);
    }
 
    // Token: 0x0600266D RID: 9837 RVA: 0x000D8BB5 File Offset: 0x000D6DB5
    public static LayerDragGrid CreateGacha(TraitGacha gacha)
    {
        Msg.Say("target_what");
        return LayerDragGrid.Create(new InvOwnerGacha(gacha.owner, null, CurrencyType.None)
        {
            gacha = gacha
        }, false);
    }
 
    // Token: 0x0600266E RID: 9838 RVA: 0x000D8BDC File Offset: 0x000D6DDC
    public static LayerDragGrid TryProc(Chara cc, InvOwnerEffect owner)
    {
        owner.cc = cc;
        if (cc.IsPC)
        {
            return LayerDragGrid.Create(owner, false);
        }
        int num = (owner.count == -1) ? 1 : owner.count;
        int i = 0;
        Func<Thing, bool> <>9__0;
        while (i < num)
        {
            ThingContainer things = cc.things;
            Func<Thing, bool> func;
            if ((func = <>9__0) == null)
            {
                func = (<>9__0 = ((Thing t) => owner.ShouldShowGuide(t)));
            }
            List<Thing> list = things.List(func, false);
            if (list.Count > 0)
            {
                Thing t2 = list.RandomItem<Thing>();
                owner._OnProcess(t2);
                i++;
            }
            else
            {
                if (i == 0)
                {
                    cc.SayNothingHappans();
                    break;
                }
                break;
            }
        }
        return null;
    }
 
    // Token: 0x0600266F RID: 9839 RVA: 0x000D8C9A File Offset: 0x000D6E9A
    public static LayerDragGrid CreateIdentify(Chara cc, bool superior = false, BlessedState state = BlessedState.Normal, int price = 0, int count = 1)
    {
        return LayerDragGrid.TryProc(cc, new InvOwnerIdentify
        {
            state = state,
            price = price,
            count = count,
            superior = superior
        });
    }
 
    // Token: 0x06002670 RID: 9840 RVA: 0x000D8CC4 File Offset: 0x000D6EC4
    public static LayerDragGrid CreateEnchant(Chara cc, bool armor, bool superior = false, BlessedState state = BlessedState.Normal, int count = 1)
    {
        return LayerDragGrid.TryProc(cc, new InvOwnerEnchant
        {
            armor = armor,
            state = state,
            superior = superior,
            count = count
        });
    }
 
    // Token: 0x06002671 RID: 9841 RVA: 0x000D8CEE File Offset: 0x000D6EEE
    public static LayerDragGrid CreateChangeMaterial(Chara cc, Thing consume, SourceMaterial.Row mat, EffectId idEffect, BlessedState state = BlessedState.Normal, int price = 0, int count = 1)
    {
        return LayerDragGrid.TryProc(cc, new InvOwnerChangeMaterial
        {
            consume = consume,
            mat = mat,
            state = state,
            price = price,
            count = count,
            idEffect = idEffect
        });
    }
 
    // Token: 0x06002672 RID: 9842 RVA: 0x000D8D28 File Offset: 0x000D6F28
    public static LayerDragGrid CreateUncurse(Chara cc, BlessedState state = BlessedState.Normal, int price = 0, int count = 1)
    {
        return LayerDragGrid.TryProc(cc, new InvOwnerUncurse
        {
            state = state,
            price = price,
            count = count
        });
    }
 
    // Token: 0x06002673 RID: 9843 RVA: 0x000D8D4A File Offset: 0x000D6F4A
    public static LayerDragGrid CreateLighten(Chara cc, BlessedState state = BlessedState.Normal, int price = 0, int count = 1)
    {
        return LayerDragGrid.TryProc(cc, new InvOwnerLighten
        {
            state = state,
            price = price,
            count = count
        });
    }
 
    // Token: 0x06002674 RID: 9844 RVA: 0x000D8D6C File Offset: 0x000D6F6C
    public static LayerDragGrid CreateReconstruction(Chara cc, BlessedState state = BlessedState.Normal, int price = 0, int count = 1)
    {
        return LayerDragGrid.TryProc(cc, new InvOwnerReconstruction
        {
            state = state,
            price = price,
            count = count
        });
    }
 
    // Token: 0x04001508 RID: 5384
    public static LayerDragGrid Instance;
 
    // Token: 0x04001509 RID: 5385
    public UIItem itemCost;
 
    // Token: 0x0400150A RID: 5386
    public Image imageOwner;
 
    // Token: 0x0400150B RID: 5387
    public UIText textTitle;
 
    // Token: 0x0400150C RID: 5388
    public UIText textFuel;
 
    // Token: 0x0400150D RID: 5389
    public Transform transIndex;
 
    // Token: 0x0400150E RID: 5390
    public List<ButtonGrid> buttons;
 
    // Token: 0x0400150F RID: 5391
    public ButtonGrid buttonOwner;
 
    // Token: 0x04001510 RID: 5392
    public UIButton buttonRefuel;
 
    // Token: 0x04001511 RID: 5393
    public UIButton buttonAutoRefuel;
 
    // Token: 0x04001512 RID: 5394
    public UIButton buttonAlly;
 
    // Token: 0x04001513 RID: 5395
    public InvOwnerDraglet owner;
 
    // Token: 0x04001514 RID: 5396
    public UICurrency uiCurrency;
 
    // Token: 0x04001515 RID: 5397
    public int currentIndex;
 
    // Token: 0x04001516 RID: 5398
    public UIDragGridInfo info;
 
    // Token: 0x04001517 RID: 5399
    public UIList listAlly;
 
    // Token: 0x04001518 RID: 5400
    private bool wasInventoryOpen;
 
    // Token: 0x04001519 RID: 5401
    private int lastNum;
}