DropdownGrid.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x0200050C RID: 1292
public class DropdownGrid : EMono
{
    // Token: 0x06002290 RID: 8848 RVA: 0x000C04C1 File Offset: 0x000BE6C1
    private void Awake()
    {
        this.rectDrop.SetActive(false);
    }
 
    // Token: 0x06002291 RID: 8849 RVA: 0x000C04CF File Offset: 0x000BE6CF
    private void Update()
    {
        this.rectDrop.SetActive(DropdownGrid.IsActive);
    }
 
    // Token: 0x06002292 RID: 8850 RVA: 0x000C04E4 File Offset: 0x000BE6E4
    public void Build(List<GridItem> items)
    {
        this.list.Clear();
        BaseList baseList = this.list;
        UIList.Callback<GridItem, ButtonGrid> callback = new UIList.Callback<GridItem, ButtonGrid>();
        callback.onInstantiate = delegate(GridItem a, ButtonGrid b)
        {
            a.SetButton(b);
        };
        callback.onClick = delegate(GridItem a, ButtonGrid b)
        {
            a.OnClick(b);
        };
        callback.onRedraw = delegate(GridItem a, ButtonGrid b, int i)
        {
            a.SetButton(b);
        };
        baseList.callbacks = callback;
        for (int j = 0; j < this.slots; j++)
        {
            if (j < items.Count)
            {
                this.list.Add(items[j]);
            }
            else
            {
                this.list.Add(new GridItem());
            }
        }
        this.list.Refresh(false);
    }
 
    // Token: 0x06002293 RID: 8851 RVA: 0x000C05C5 File Offset: 0x000BE7C5
    public List<Thing> ListIngredients(Recipe.Ingredient ingredient, StockSearchMode searchMode)
    {
        return EMono._map.Stocked.ListThingStack(ingredient, searchMode).list;
    }
 
    // Token: 0x06002294 RID: 8852 RVA: 0x000C05E0 File Offset: 0x000BE7E0
    public void BuildIngredients(Recipe _recipe, Image _icon, Action _onValueChange, StockSearchMode _searchMode)
    {
        this.recipe = _recipe;
        this.icon = _icon;
        this.list.Clear();
        this.onValueChange = _onValueChange;
        this.searchMode = _searchMode;
        if (this.recipe == null)
        {
            return;
        }
        this.list.callbacks = new UIList.Callback<Recipe.Ingredient, ButtonGrid>
        {
            onInstantiate = delegate(Recipe.Ingredient ingredient, ButtonGrid b)
            {
                if (ingredient.id.IsEmpty())
                {
                    b.SetIngredient(this.recipe, ingredient);
                    return;
                }
                List<Thing> things = this.ListIngredients(ingredient, this.searchMode);
                if (things.Count == 0)
                {
                    if (EMono.debug.godBuild && ingredient.thing == null)
                    {
                        Thing thing = ThingGen.Create(ingredient.IdThing, this.recipe.DefaultMaterial.alias).SetNum(99);
                        things.Add(thing);
                        ingredient.SetThing(thing);
                    }
                    else
                    {
                        ingredient.SetThing(null);
                        things.Insert(0, null);
                    }
                }
                else if (!ingredient.optional)
                {
                    if (ingredient.thing == null)
                    {
                        int num = this.lastMats.TryGetValue(this.recipe.id, -1);
                        if (num != -1)
                        {
                            foreach (Thing thing2 in things)
                            {
                                if (thing2.material.id == num && thing2.Num >= ingredient.req)
                                {
                                    ingredient.SetThing(thing2);
                                    break;
                                }
                            }
                        }
                        if (ingredient.thing == null)
                        {
                            SourceMaterial.Row defaultMaterial = this.recipe.DefaultMaterial;
                            foreach (Thing thing3 in things)
                            {
                                if (thing3.material.id == defaultMaterial.id && thing3.Num >= ingredient.req)
                                {
                                    ingredient.SetThing(thing3);
                                    break;
                                }
                            }
                            if (EMono.debug.godBuild && ingredient.thing == null)
                            {
                                Thing thing4 = (ingredient.useCat ? ThingGen.CreateFromCategory(ingredient.id, -1) : ThingGen.Create(ingredient.id, defaultMaterial.alias)).SetNum(99);
                                things.Add(thing4);
                                ingredient.SetThing(thing4);
                            }
                        }
                        if (ingredient.thing == null)
                        {
                            ingredient.SetThing(things[0]);
                        }
                    }
                    else
                    {
                        bool flag = true;
                        foreach (Thing thing5 in things)
                        {
                            if (ingredient.thing == thing5)
                            {
                                flag = false;
                                break;
                            }
                        }
                        if (flag)
                        {
                            ingredient.SetThing(things[0]);
                        }
                    }
                }
                b.SetIngredient(this.recipe, ingredient);
                b.onClick.RemoveAllListeners();
                b.onClick.AddListener(delegate()
                {
                    things = this.ListIngredients(ingredient, this.searchMode);
                    if (ingredient.optional)
                    {
                        if (things.Count == 0 || things[0] == null)
                        {
                            SE.Beep();
                            return;
                        }
                    }
                    else if (ingredient.thing == null)
                    {
                        SE.Beep();
                        return;
                    }
                    if (this.rectDrop)
                    {
                        this.Activate(ingredient, things);
                        this.rectDropContent.position = this.list.transform.position + this.fixPos;
                    }
                });
            },
            onRedraw = delegate(Recipe.Ingredient a, ButtonGrid b, int i)
            {
                b.SetIngredient(this.recipe, a);
            }
        };
        for (int j = 0; j < this.slots; j++)
        {
            if (j < this.recipe.ingredients.Count)
            {
                this.list.Add(this.recipe.ingredients[j]);
            }
            else
            {
                this.list.Add(new Recipe.Ingredient
                {
                    id = ""
                });
            }
        }
        this.list.Refresh(false);
    }
 
    // Token: 0x06002295 RID: 8853 RVA: 0x000C06BB File Offset: 0x000BE8BB
    public void Redraw()
    {
        this.list.Redraw();
    }
 
    // Token: 0x06002296 RID: 8854 RVA: 0x000C06C8 File Offset: 0x000BE8C8
    public void Activate(Recipe.Ingredient ingredient, List<Thing> things)
    {
        if (this.soundPop)
        {
            this.soundPop.Play();
        }
        DropdownGrid.IsActive = true;
        DropdownGrid.Instance = this;
        this.rectDrop.SetActive(true);
        this.rectDrop.SetParent(EMono.ui.transform);
        this.rectDrop.sizeDelta = new Vector2(0f, 0f);
        this.rectDrop.anchoredPosition = Vector3.zero;
        this.listDrop.callbacks = new UIList.Callback<Thing, ButtonGrid>
        {
            onClick = delegate(Thing a, ButtonGrid b)
            {
                SE.Resource();
                ingredient.SetThing(a);
                this.OnChangeIngredient();
                if (this.onValueChange != null)
                {
                    this.onValueChange();
                }
                this.Deactivate();
                if (LayerCraft.Instance)
                {
                    LayerCraft.Instance.OnChangeIngredient();
                }
            },
            onInstantiate = delegate(Thing a, ButtonGrid b)
            {
                b.SetIngredient(this.recipe, a);
            }
        };
        this.listDrop.Clear();
        foreach (Thing o in things)
        {
            this.listDrop.Add(o);
        }
        this.listDrop.Refresh(false);
    }
 
    // Token: 0x06002297 RID: 8855 RVA: 0x000C07F0 File Offset: 0x000BE9F0
    public void OnChangeIngredient()
    {
        if (this.recipe == null)
        {
            return;
        }
        this.recipe.OnChangeIngredient();
        if (!this.rectDrop)
        {
            return;
        }
        if (this.icon)
        {
            this.recipe.renderRow.SetImage(this.icon, null, this.recipe.renderRow.GetColorInt(this.recipe.GetColorMaterial()), true, 0, this.recipe.idSkin);
        }
        this.list.Redraw();
    }
 
    // Token: 0x06002298 RID: 8856 RVA: 0x000C0876 File Offset: 0x000BEA76
    public void Deactivate()
    {
        DropdownGrid.IsActive = false;
        if (this.rectDrop != null)
        {
            this.rectDrop.SetActive(false);
        }
    }
 
    // Token: 0x06002299 RID: 8857 RVA: 0x000C0898 File Offset: 0x000BEA98
    public void OnDestroy()
    {
        DropdownGrid.IsActive = false;
        UnityEngine.Object.DestroyImmediate(this.rectDrop.gameObject);
    }
 
    // Token: 0x0600229A RID: 8858 RVA: 0x000C08B0 File Offset: 0x000BEAB0
    public void TrySelect(int a)
    {
        ButtonGrid componentOf = InputModuleEX.GetComponentOf<ButtonGrid>();
        if (!componentOf || componentOf.ing == null)
        {
            return;
        }
        Recipe.Ingredient ing = componentOf.ing;
        List<Thing> list = EMono._map.Stocked.ListThingStack(ing, this.searchMode).list;
        int num = list.IndexOf(ing.thing);
        if (num == -1)
        {
            return;
        }
        SE.Resource();
        num += a;
        if (num < 0)
        {
            num = 0;
        }
        if (num >= list.Count)
        {
            num = list.Count - 1;
        }
        ing.SetThing(list[num]);
        this.OnChangeIngredient();
        TooltipManager.Instance.ResetTooltips();
        componentOf.ShowTooltip();
        if (this.recipeInfo)
        {
            this.recipeInfo.RefreshImages();
        }
        if (LayerCraft.Instance)
        {
            LayerCraft.Instance.RefreshProduct();
        }
    }
 
    // Token: 0x0600229B RID: 8859 RVA: 0x000C097B File Offset: 0x000BEB7B
    public void Next()
    {
        this.TrySelect(1);
    }
 
    // Token: 0x0600229C RID: 8860 RVA: 0x000C0984 File Offset: 0x000BEB84
    public void Prev()
    {
        this.TrySelect(-1);
    }
 
    // Token: 0x040011E4 RID: 4580
    public static bool IsActive;
 
    // Token: 0x040011E5 RID: 4581
    public static DropdownGrid Instance;
 
    // Token: 0x040011E6 RID: 4582
    public UIList list;
 
    // Token: 0x040011E7 RID: 4583
    public UIList listDrop;
 
    // Token: 0x040011E8 RID: 4584
    public RectTransform rectDrop;
 
    // Token: 0x040011E9 RID: 4585
    public RectTransform rectDropContent;
 
    // Token: 0x040011EA RID: 4586
    public RectTransform pivot;
 
    // Token: 0x040011EB RID: 4587
    public Recipe recipe;
 
    // Token: 0x040011EC RID: 4588
    public Image icon;
 
    // Token: 0x040011ED RID: 4589
    public SoundData soundPop;
 
    // Token: 0x040011EE RID: 4590
    public Action onValueChange;
 
    // Token: 0x040011EF RID: 4591
    public int slots = 4;
 
    // Token: 0x040011F0 RID: 4592
    public Vector3 fixPos;
 
    // Token: 0x040011F1 RID: 4593
    public StockSearchMode searchMode;
 
    // Token: 0x040011F2 RID: 4594
    public UIRecipeInfo recipeInfo;
 
    // Token: 0x040011F3 RID: 4595
    [NonSerialized]
    public Dictionary<string, int> lastMats = new Dictionary<string, int>();
}