UIInspector.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x020005D3 RID: 1491
public class UIInspector : ELayer
{
    // Token: 0x17000BDE RID: 3038
    // (get) Token: 0x0600290E RID: 10510 RVA: 0x000E8160 File Offset: 0x000E6360
    public bool IsActive
    {
        get
        {
            return base.gameObject.activeSelf;
        }
    }
 
    // Token: 0x0600290F RID: 10511 RVA: 0x000E816D File Offset: 0x000E636D
    public void SetVisible(bool enable)
    {
        base.gameObject.SetActive(enable && this.group != null);
        if (enable && this.group != null)
        {
            this.Refresh();
        }
    }
 
    // Token: 0x06002910 RID: 10512 RVA: 0x000E819A File Offset: 0x000E639A
    public void Hide()
    {
        this.group = null;
        this.point = null;
        base.gameObject.SetActive(false);
    }
 
    // Token: 0x06002911 RID: 10513 RVA: 0x000E81B8 File Offset: 0x000E63B8
    public bool InspectUnderMouse()
    {
        if (!Scene.HitPoint.IsValid)
        {
            return false;
        }
        List<IInspect> list = ELayer.scene.mouseTarget.pos.ListInspectorTargets();
        this.point = Scene.HitPoint;
        IList<IInspect> source = list;
        InspectGroup inspectGroup = this.group;
        this.Inspect(source.NextItem((inspectGroup != null) ? inspectGroup.FirstTarget : null));
        return true;
    }
 
    // Token: 0x06002912 RID: 10514 RVA: 0x000E8212 File Offset: 0x000E6412
    public void Inspect(IInspect newTarget)
    {
        InspectGroup inspectGroup = this.group;
        if (((inspectGroup != null) ? inspectGroup.FirstTarget : null) == newTarget)
        {
            return;
        }
        this.Inspect(InspectGroup.Create(newTarget));
    }
 
    // Token: 0x06002913 RID: 10515 RVA: 0x000E8238 File Offset: 0x000E6438
    public void Inspect(InspectGroup g)
    {
        base.gameObject.SetActive(true);
        if (!this.initialized)
        {
            this.windows.Add(this.windowChara.window);
            this.initialized = true;
            this.mold = this.layoutButtons.CreateMold(null);
            IUISkin[] componentsInChildren = base.transform.GetComponentsInChildren<IUISkin>(true);
            for (int i = 0; i < componentsInChildren.Length; i++)
            {
                componentsInChildren[i].ApplySkin();
            }
            base.InitInspector();
        }
        this.group = g;
        this.soundPop.Play();
        this.Refresh();
    }
 
    // Token: 0x06002914 RID: 10516 RVA: 0x000E82CC File Offset: 0x000E64CC
    public void OnUpdate()
    {
        if (this.group == null || !this.IsActive)
        {
            return;
        }
        if (!this.group.CanInspect())
        {
            this.Hide();
            return;
        }
        foreach (IInspect i in this.group.targets)
        {
            this.DrawHighlight(i, true);
        }
    }
 
    // Token: 0x06002915 RID: 10517 RVA: 0x000E834C File Offset: 0x000E654C
    public void Refresh()
    {
        if (!this.group.CanInspect())
        {
            this.Hide();
            return;
        }
        this.group.SetActions();
        this.layoutButtons.DestroyChildren(false, true);
        using (List<InspectGroup.Item>.Enumerator enumerator = this.group.actions.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                InspectGroup.Item item = enumerator.Current;
                if (this.group.Solo || item.multi)
                {
                    UIButton uibutton = Util.Instantiate<UIButton>(this.mold, this.layoutButtons);
                    uibutton.icon.sprite = (SpriteSheet.Get(item.idSprite.IsEmpty("icon_" + item.text)) ?? uibutton.icon.sprite);
                    uibutton.mainText.SetText((item.textFunc != null) ? item.textFunc() : item.text.lang());
                    uibutton.onClick.AddListener(delegate()
                    {
                        if (this.group.CanInspect())
                        {
                            if (item.sound)
                            {
                                this.soundPop.Play();
                            }
                            foreach (IInspect obj in this.group.targets)
                            {
                                item.action(obj);
                            }
                        }
                        if (this.group == null || !this.group.CanInspect())
                        {
                            this.Hide();
                            return;
                        }
                        this.Refresh();
                    });
                    uibutton.RebuildLayout(true);
                }
            }
        }
        Chara chara = this.group.FirstTarget as Chara;
        bool flag = this.group.Solo && chara != null && chara.IsHomeMember();
        Room room = null;
        if (!flag && ELayer.core.IsGameStarted && this.point != null)
        {
            room = this.point.cell.room;
        }
        bool flag2 = room != null;
        this.windowChara.SetActive(flag);
        this.rectInfo.SetActive(!flag);
        this.rectRoom.SetActive(flag2);
        this.note.Clear();
        if (flag)
        {
            this.windowChara.SetChara(chara);
        }
        else if (this.group.Solo)
        {
            this.group.FirstTarget.WriteNote(this.note, null, IInspect.NoteMode.Default, null);
        }
        else
        {
            this.note.AddHeader(this.group.GetName(), null);
            this.note.Build();
        }
        if (flag2)
        {
            UINote uinote = this.noteRoom;
            uinote.Clear();
            uinote.AddHeader("Room", null);
            uinote.AddText(room.points.Count.ToString() ?? "", FontColor.DontChange);
            uinote.Build();
        }
        this.layoutButtons.RebuildLayout(true);
        this.layoutBody.RebuildLayout(false);
        this.group.FirstTarget.OnInspect();
    }
 
    // Token: 0x06002916 RID: 10518 RVA: 0x000E8620 File Offset: 0x000E6820
    public unsafe void DrawHighlight(IInspect i, bool selected = false)
    {
        UIInspector.<>c__DisplayClass25_0 CS$<>8__locals1 = new UIInspector.<>c__DisplayClass25_0();
        if (i is Area || i is EloPos)
        {
            return;
        }
        CS$<>8__locals1.v = i.InspectPosition;
        Point inspectPoint = i.InspectPoint;
        if (inspectPoint == null)
        {
            return;
        }
        MeshPass meshPass = (inspectPoint.HasNonWallBlock || inspectPoint.HasBlockRecipe) ? ELayer.screen.guide.passGuideBlock : ELayer.screen.guide.passGuideFloor;
        if (i is Chara)
        {
            CS$<>8__locals1.v += ELayer.screen.pcOrbit.crystal.transform.position;
            ELayer.screen.tileMap.passIcon.Add(ref CS$<>8__locals1.v, 1f, 0f);
            return;
        }
        if (i is Thing)
        {
            Thing thing = i as Thing;
            if (thing.IsInstalled && thing.sourceCard.multisize)
            {
                if (selected)
                {
                    thing.ForeachPoint(delegate(Point pos, bool main)
                    {
                        CS$<>8__locals1.v = *pos.Position();
                        CS$<>8__locals1.v.z = CS$<>8__locals1.v.z - 0.01f;
                        ELayer.screen.guide.passGuideFloor.Add(ref CS$<>8__locals1.v, 7f, 0f);
                    });
                }
                return;
            }
            if (thing.TileType.IsBlockMount)
            {
                meshPass = ELayer.screen.guide.passGuideBlock;
            }
        }
        else if (i is TaskBuild)
        {
            Recipe recipe = (i as TaskBuild).recipe;
            if (recipe.MultiSize)
            {
                if (selected)
                {
                    i.InspectPoint.ForeachMultiSize(recipe.W, recipe.H, delegate(Point pos, bool main)
                    {
                        CS$<>8__locals1.v = *pos.Position();
                        CS$<>8__locals1.v.z = CS$<>8__locals1.v.z - 0.01f;
                        ELayer.screen.guide.passGuideBlock.Add(ref CS$<>8__locals1.v, 7f, 0f);
                    });
                }
                return;
            }
        }
        UIInspector.<>c__DisplayClass25_0 CS$<>8__locals2 = CS$<>8__locals1;
        CS$<>8__locals2.v.z = CS$<>8__locals2.v.z - 0.01f;
        meshPass.Add(ref CS$<>8__locals1.v, 7f, 0f);
    }
 
    // Token: 0x04001731 RID: 5937
    public InspectGroup group;
 
    // Token: 0x04001732 RID: 5938
    public LayoutGroup layoutBody;
 
    // Token: 0x04001733 RID: 5939
    public LayoutGroup layoutButtons;
 
    // Token: 0x04001734 RID: 5940
    public UIButton mold;
 
    // Token: 0x04001735 RID: 5941
    public Vector3 offset;
 
    // Token: 0x04001736 RID: 5942
    public Vector3 modPos;
 
    // Token: 0x04001737 RID: 5943
    public SoundData soundPop;
 
    // Token: 0x04001738 RID: 5944
    public WindowChara windowChara;
 
    // Token: 0x04001739 RID: 5945
    public RectTransform rectInfo;
 
    // Token: 0x0400173A RID: 5946
    public RectTransform rectRoom;
 
    // Token: 0x0400173B RID: 5947
    public UINote note;
 
    // Token: 0x0400173C RID: 5948
    public UINote noteRoom;
 
    // Token: 0x0400173D RID: 5949
    public UIText textName;
 
    // Token: 0x0400173E RID: 5950
    public UIImage bg;
 
    // Token: 0x0400173F RID: 5951
    public Point point;
 
    // Token: 0x04001740 RID: 5952
    private bool initialized;
}