UIMapPreview.cs

using System;
using System.Collections.Generic;
using System.Threading;
using UnityEngine;
using UnityEngine.UI;
 
// Token: 0x02000623 RID: 1571
public class UIMapPreview : EMono
{
    // Token: 0x06002BF6 RID: 11254 RVA: 0x000F6DB2 File Offset: 0x000F4FB2
    private void Awake()
    {
        if (this.image)
        {
            this.texDefault = this.image.texture;
        }
    }
 
    // Token: 0x06002BF7 RID: 11255 RVA: 0x000F6DD4 File Offset: 0x000F4FD4
    public void GenerateMap(ZoneBlueprint bp)
    {
        if (this.thread == null)
        {
            this.thread = new UIMapPreview.GenThread();
            this.thread.Init();
        }
        else
        {
            if (!this.thread.done)
            {
                return;
            }
            this.image.texture = this.texDefault;
            this.thread.Reset();
        }
        this.thread.bp.genSetting = bp.genSetting;
        this.thread.bp.zoneProfile = bp.zoneProfile;
        this.thread.bp.genSetting.seed = EMono.rnd(20000);
        ThreadPool.QueueUserWorkItem(delegate(object a)
        {
            this.thread.Start();
        });
        base.CancelInvoke();
        base.InvokeRepeating("CheckThread", 0f, 0.1f);
    }
 
    // Token: 0x06002BF8 RID: 11256 RVA: 0x000F6EA3 File Offset: 0x000F50A3
    public void CheckThread()
    {
        if (this.thread.done)
        {
            this.SetMap(this.thread.bp.map);
            base.CancelInvoke();
        }
    }
 
    // Token: 0x06002BF9 RID: 11257 RVA: 0x000F6ED0 File Offset: 0x000F50D0
    public void SetMap(Map _map)
    {
        this.map = _map;
        if (_map == null)
        {
            this.image.texture = this.texDefault;
            return;
        }
        this.cells = this.map.cells;
        int num = this.limitBounds ? ((this.map.bounds.Width > this.map.bounds.Height) ? this.map.bounds.Width : this.map.bounds.Height) : this.map.Size;
        this.Size = num;
        this.offsetX = ((this.map.bounds.Width > this.map.bounds.Height) ? 0 : ((num - _map.bounds.Width) / 2));
        this.offsetZ = ((this.map.bounds.Width > this.map.bounds.Height) ? ((num - _map.bounds.Height) / 2) : 0);
        this.px = new Color[this.Size * this.Size];
        if (this.tex)
        {
            UnityEngine.Object.DestroyImmediate(this.tex);
        }
        this.tex = new Texture2D(this.Size, this.Size)
        {
            filterMode = this.filter,
            wrapMode = TextureWrapMode.Clamp
        };
        for (int i = 0; i < this.Size * this.Size; i++)
        {
            this.px[i].a = this.voidAlpha;
        }
        this.tex.SetPixels(this.px);
        if (this.limitBounds)
        {
            for (int j = 0; j < this.map.bounds.Height; j++)
            {
                for (int k = 0; k < this.map.bounds.Width; k++)
                {
                    this._RefreshPoint(this.map.bounds.x + k, this.map.bounds.z + j, false);
                }
            }
        }
        else
        {
            for (int l = 0; l < this.Size; l++)
            {
                for (int m = 0; m < this.Size; m++)
                {
                    this._RefreshPoint(m, l, false);
                }
            }
        }
        this.tex.SetPixels(this.px);
        this.tex.Apply();
        if (this.matMap)
        {
            this.matMap.SetTexture("_MainTex", this.tex);
        }
        if (this.image)
        {
            this.image.texture = this.tex;
        }
    }
 
    // Token: 0x06002BFA RID: 11258 RVA: 0x000F7176 File Offset: 0x000F5376
    public void UpdateMap(int x, int z)
    {
        this._RefreshPoint(x, z, true);
        this.tex.Apply();
    }
 
    // Token: 0x06002BFB RID: 11259 RVA: 0x000F718C File Offset: 0x000F538C
    public void UpdateMap(List<Cell> newPoints)
    {
        foreach (Cell cell in newPoints)
        {
            this._RefreshPoint((int)cell.x, (int)cell.z, true);
        }
        this.tex.Apply();
    }
 
    // Token: 0x06002BFC RID: 11260 RVA: 0x000F71F4 File Offset: 0x000F53F4
    public void _RefreshPoint(int x, int z, bool apply = true)
    {
        if (x >= EMono._map.Size || z >= EMono._map.Size)
        {
            return;
        }
        Cell cell = this.cells[x, z];
        int num = x;
        int num2 = z;
        if (this.limitBounds)
        {
            num = x - EMono._map.bounds.x + this.offsetX;
            num2 = z - EMono._map.bounds.z + this.offsetZ;
        }
        int num3 = num2 * this.Size + num;
        if (num3 >= this.px.Length || num3 < 0)
        {
            return;
        }
        if (this.monoColor)
        {
            if (!cell.isSeen)
            {
                this.px[num3] = this.colorSurround;
            }
            else if (cell.isSurrounded)
            {
                this.px[num3] = this.colorSurround;
            }
            else if (cell.IsTopWater)
            {
                this.px[num3] = this.colorWater;
            }
            else if (cell.HasBlock)
            {
                this.px[num3] = this.colorEdge;
            }
            else
            {
                this.px[num3] = this.colorDefault;
            }
        }
        else if (!cell.isSeen)
        {
            this.px[num3] = this.colorSurround;
        }
        else if (cell.HasZoneStairs(true))
        {
            this.px[num3] = this.colorStairs;
        }
        else if (cell.isSurrounded)
        {
            this.px[num3] = this.colorSurround;
        }
        else if (cell.HasBlock)
        {
            this.px[num3] = cell.matBlock.GetColor();
        }
        else
        {
            SourceMaterial.Row row = (cell.bridgeHeight != 0) ? cell.matBridge : cell.matFloor;
            if (!Application.isEditor && !EMono._zone.IsRegion && cell.IsSnowTile)
            {
                row = MATERIAL.sourceSnow;
            }
            Color color = cell.IsSky ? this.colorSky : row.GetColor();
            if (color.r > this.maxColor)
            {
                color.r = this.maxColor;
            }
            else if (color.r < this.minColor)
            {
                color.r = this.minColor;
            }
            if (color.g > this.maxColor)
            {
                color.g = this.maxColor;
            }
            else if (color.g < this.minColor)
            {
                color.g = this.minColor;
            }
            if (color.b > this.maxColor)
            {
                color.b = this.maxColor;
            }
            else if (color.b < this.minColor)
            {
                color.b = this.minColor;
            }
            this.px[num3] = color;
        }
        if (cell.isSeen)
        {
            if (cell.HasBlock)
            {
                this.px[num3] *= 0.4f;
            }
            else if (cell.room != null)
            {
                this.px[num3] *= 0.9f;
            }
        }
        if (!EMono._map.bounds.Contains(x, z))
        {
            this.px[num3].a = this.voidAlpha;
        }
        else
        {
            this.px[num3].a = 1f;
        }
        if (!apply)
        {
            return;
        }
        this.tex.SetPixel(num, num2, this.px[num3]);
    }
 
    // Token: 0x04001886 RID: 6278
    public Color colorDefault;
 
    // Token: 0x04001887 RID: 6279
    public Color colorWater;
 
    // Token: 0x04001888 RID: 6280
    public Color colorSurround;
 
    // Token: 0x04001889 RID: 6281
    public Color colorEdge;
 
    // Token: 0x0400188A RID: 6282
    public Color colorFog;
 
    // Token: 0x0400188B RID: 6283
    public Color colorSky;
 
    // Token: 0x0400188C RID: 6284
    public Color colorStairs;
 
    // Token: 0x0400188D RID: 6285
    public Material matMap;
 
    // Token: 0x0400188E RID: 6286
    public RawImage image;
 
    // Token: 0x0400188F RID: 6287
    public UIButton button;
 
    // Token: 0x04001890 RID: 6288
    private Texture texDefault;
 
    // Token: 0x04001891 RID: 6289
    private Texture2D tex;
 
    // Token: 0x04001892 RID: 6290
    private Color[] px;
 
    // Token: 0x04001893 RID: 6291
    private Cell[,] cells;
 
    // Token: 0x04001894 RID: 6292
    [NonSerialized]
    public int Size;
 
    // Token: 0x04001895 RID: 6293
    [NonSerialized]
    public int offsetX;
 
    // Token: 0x04001896 RID: 6294
    [NonSerialized]
    public int offsetZ;
 
    // Token: 0x04001897 RID: 6295
    public FilterMode filter = FilterMode.Bilinear;
 
    // Token: 0x04001898 RID: 6296
    public Map map;
 
    // Token: 0x04001899 RID: 6297
    public bool monoColor;
 
    // Token: 0x0400189A RID: 6298
    public bool createNewMaterial;
 
    // Token: 0x0400189B RID: 6299
    public bool limitBounds;
 
    // Token: 0x0400189C RID: 6300
    public UIMapPreview.GenThread thread;
 
    // Token: 0x0400189D RID: 6301
    public float voidAlpha;
 
    // Token: 0x0400189E RID: 6302
    public float minColor;
 
    // Token: 0x0400189F RID: 6303
    public float maxColor;
 
    // Token: 0x02000B96 RID: 2966
    public class GenThread : EClass
    {
        // Token: 0x060044A9 RID: 17577 RVA: 0x0015CB78 File Offset: 0x0015AD78
        public void Init()
        {
            this.bp = new ZoneBlueprint();
            this.bp.Create();
            this.Reset();
        }
 
        // Token: 0x060044AA RID: 17578 RVA: 0x0015CB96 File Offset: 0x0015AD96
        public void Reset()
        {
            this.done = false;
        }
 
        // Token: 0x060044AB RID: 17579 RVA: 0x0015CB9F File Offset: 0x0015AD9F
        public void Start()
        {
            this.done = true;
        }
 
        // Token: 0x04002E74 RID: 11892
        public ZoneBlueprint bp;
 
        // Token: 0x04002E75 RID: 11893
        public Map map;
 
        // Token: 0x04002E76 RID: 11894
        public bool done = true;
    }
}