WidgetMinimap.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
 
// Token: 0x02000624 RID: 1572
public class WidgetMinimap : Widget, IPointerDownHandler, IEventSystemHandler, IPointerUpHandler, IDragHandler, IChangeResolution, IInitializePotentialDragHandler
{
    // Token: 0x06002BFF RID: 11263 RVA: 0x000F7589 File Offset: 0x000F5789
    public override object CreateExtra()
    {
        return new WidgetMinimap.Extra();
    }
 
    // Token: 0x17000C95 RID: 3221
    // (get) Token: 0x06002C00 RID: 11264 RVA: 0x000F7590 File Offset: 0x000F5790
    public override Type SetSiblingAfter
    {
        get
        {
            return typeof(WidgetBottomBar);
        }
    }
 
    // Token: 0x17000C96 RID: 3222
    // (get) Token: 0x06002C01 RID: 11265 RVA: 0x000F759C File Offset: 0x000F579C
    public WidgetMinimap.Extra extra
    {
        get
        {
            return base.config.extra as WidgetMinimap.Extra;
        }
    }
 
    // Token: 0x17000C97 RID: 3223
    // (get) Token: 0x06002C02 RID: 11266 RVA: 0x000F75AE File Offset: 0x000F57AE
    public int Size
    {
        get
        {
            return this.preview.Size;
        }
    }
 
    // Token: 0x17000C98 RID: 3224
    // (get) Token: 0x06002C03 RID: 11267 RVA: 0x000F75BB File Offset: 0x000F57BB
    public override bool AlwaysBottom
    {
        get
        {
            return true;
        }
    }
 
    // Token: 0x06002C04 RID: 11268 RVA: 0x000F75C0 File Offset: 0x000F57C0
    public override void OnActivate()
    {
        WidgetMinimap.Instance = this;
        this.preview.limitBounds = this.extra.limitBounds;
        this.preview.monoColor = this.extra.monoColor;
        this.preview.SetMap(EMono._map);
        base.InvokeRepeating("RefreshMarkers", 0f, this.interval);
        this.RefreshStyle();
        this.buttonMaptool.SetItem(new HotItemContext
        {
            id = "mapTool"
        });
    }
 
    // Token: 0x06002C05 RID: 11269 RVA: 0x000F7646 File Offset: 0x000F5846
    public static void UpdateMap(List<Cell> newPoints)
    {
        if (WidgetMinimap.Instance && WidgetMinimap.Instance.preview.map.zone.IsActiveZone)
        {
            WidgetMinimap.Instance.preview.UpdateMap(newPoints);
        }
        newPoints.Clear();
    }
 
    // Token: 0x06002C06 RID: 11270 RVA: 0x000F7685 File Offset: 0x000F5885
    public static void UpdateMap(int x, int z)
    {
        if (WidgetMinimap.Instance && WidgetMinimap.Instance.preview.map.zone.IsActiveZone)
        {
            WidgetMinimap.Instance.preview.UpdateMap(x, z);
        }
    }
 
    // Token: 0x06002C07 RID: 11271 RVA: 0x000F76BF File Offset: 0x000F58BF
    public static void UpdateMap()
    {
        if (WidgetMinimap.Instance && WidgetMinimap.Instance.preview.map.zone.IsActiveZone)
        {
            WidgetMinimap.Instance.preview.SetMap(EMono._map);
        }
    }
 
    // Token: 0x06002C08 RID: 11272 RVA: 0x000F76FC File Offset: 0x000F58FC
    public void OnMoveZone()
    {
        this.preview.SetMap(EMono._map);
        this.RefreshStyle();
    }
 
    // Token: 0x06002C09 RID: 11273 RVA: 0x000F7714 File Offset: 0x000F5914
    public void Reload()
    {
        this.preview.SetMap(this.preview.map);
    }
 
    // Token: 0x06002C0A RID: 11274 RVA: 0x000F772C File Offset: 0x000F592C
    public void OnPointerDown(PointerEventData e)
    {
        if (!EMono.pc.HasNoGoal || EMono.game.activeZone.IsRegion || EMono.ui.IsActive)
        {
            SE.BeepSmall();
            return;
        }
        Vector2 size = this.rectMap.rect.size;
        Vector2 vector;
        RectTransformUtility.ScreenPointToLocalPointInRectangle(this.rectMap, e.position, e.pressEventCamera, out vector);
        if (vector.x < 0f)
        {
            vector.x = 0f;
        }
        else if (vector.x >= size.x)
        {
            vector.x = size.x;
        }
        if (vector.y < 0f)
        {
            vector.y = 0f;
        }
        else if (vector.y >= size.y)
        {
            vector.y = size.y;
        }
        this.pos.Set((int)((float)this.Size * vector.x / size.x), (int)((float)this.Size * vector.y / size.y));
        this.pos.Clamp(false);
        if (this.preview.limitBounds)
        {
            this.pos.x += EMono._map.bounds.x - this.preview.offsetX;
            this.pos.z += EMono._map.bounds.z - this.preview.offsetZ;
        }
        if (this.pos.cell.outOfBounds || !this.pos.cell.isSeen)
        {
            SE.BeepSmall();
            return;
        }
        EMono.pc.SetAIImmediate(new AI_Goto(this.pos, 0, false, false));
    }
 
    // Token: 0x06002C0B RID: 11275 RVA: 0x000F78F0 File Offset: 0x000F5AF0
    public void OnPointerUp(PointerEventData e)
    {
    }
 
    // Token: 0x06002C0C RID: 11276 RVA: 0x000F78F2 File Offset: 0x000F5AF2
    public void OnInitializePotentialDrag(PointerEventData ped)
    {
        ped.useDragThreshold = false;
    }
 
    // Token: 0x06002C0D RID: 11277 RVA: 0x000F78FC File Offset: 0x000F5AFC
    public void OnDrag(PointerEventData e)
    {
    }
 
    // Token: 0x06002C0E RID: 11278 RVA: 0x000F790C File Offset: 0x000F5B0C
    public override void OnSetContextMenu(UIContextMenu m)
    {
        UIContextMenu uicontextMenu = m.AddChild("setting");
        uicontextMenu.AddSlider("size", (float a) => this.extra.scale.ToString() ?? "", (float)this.extra.scale, delegate(float a)
        {
            this.extra.scale = (int)a;
            this.RefreshStyle();
        }, 5f, 20f, true, true, false);
        uicontextMenu.AddSlider("width", (float a) => (100 + this.extra.width).ToString() + "%", (float)this.extra.width, delegate(float a)
        {
            this.extra.width = (int)a;
            this.RefreshStyle();
        }, -25f, 25f, true, true, false);
        uicontextMenu.AddSlider("alpha", (float a) => this.extra.alpha.ToString() ?? "", (float)this.extra.alpha, delegate(float a)
        {
            this.extra.alpha = (int)a;
            this.RefreshStyle();
        }, 0f, 255f, true, true, false);
        uicontextMenu.AddToggle("rotation", this.extra.rotate, delegate(bool a)
        {
            this.extra.rotate = a;
            this.RefreshStyle();
        });
        uicontextMenu.AddToggle("monoColor", this.extra.monoColor, delegate(bool a)
        {
            WidgetMinimap.Extra extra = this.extra;
            this.preview.monoColor = a;
            extra.monoColor = a;
            this.preview.SetMap(EMono._map);
            this.RefreshStyle();
        });
        base.SetBaseContextMenu(m);
    }
 
    // Token: 0x06002C0F RID: 11279 RVA: 0x000F7A28 File Offset: 0x000F5C28
    public void RefreshStyle()
    {
        this.rectAll.localEulerAngles = ((this.extra.rotate && !EMono._zone.IsRegion) ? new Vector3(60f, 0f, -45f) : Vector3.zero);
        this.preview.matMap.SetColor("_Color", new Color(1f, 1f, 1f, (float)this.extra.alpha / 255f));
        this.Rect().sizeDelta = new Vector2(0.1f * this.baseSize.x * (float)(10 + this.extra.scale) * (float)(100 + this.extra.width) * 0.01f, 0.1f * this.baseSize.y * (float)(10 + this.extra.scale));
    }
 
    // Token: 0x06002C10 RID: 11280 RVA: 0x000F7B18 File Offset: 0x000F5D18
    public void OnUpdate()
    {
        this.point.Set(EMono.screen.position);
        if (this.preview.limitBounds)
        {
            this.point.x -= EMono._map.bounds.x - this.preview.offsetX;
            this.point.z -= EMono._map.bounds.z - this.preview.offsetZ;
        }
        float x = (float)(this.point.x / this.Size) - 0.5f;
        float y = (float)(this.point.z / this.Size) - 0.5f;
        this.transBound.localScale = new Vector3(Mathf.Min((float)EMono.screen.width / (float)this.Size * 1.5f, 1f), Mathf.Min((float)EMono.screen.height / (float)this.Size / 2f, 1f), 1f);
        this.transBound.localPosition = new Vector3(x, y, 50f);
        this.transCam.localScale = new Vector3(1f / EMono.core.uiScale, 1f / EMono.core.uiScale, 1f);
    }
 
    // Token: 0x06002C11 RID: 11281 RVA: 0x000F7C80 File Offset: 0x000F5E80
    public void RefreshMarkers()
    {
        if (!base.gameObject.activeInHierarchy)
        {
            return;
        }
        this.EmitParticle(EMono.pc, this.psAlly, this.colorAlly);
    }
 
    // Token: 0x06002C12 RID: 11282 RVA: 0x000F7CB4 File Offset: 0x000F5EB4
    public void EmitParticle(Card c, ParticleSystem ps, Color col)
    {
        int num = c.pos.x;
        int num2 = c.pos.z;
        if (this.preview.limitBounds)
        {
            num -= EMono._map.bounds.x - this.preview.offsetX;
            num2 -= EMono._map.bounds.z - this.preview.offsetZ;
        }
        float x = (float)num / (float)this.Size - 0.5f;
        float y = (float)num2 / (float)this.Size - 0.5f;
        this.count++;
        ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams
        {
            position = new Vector3(x, y, 10f),
            startSize = this.psSize,
            startLifetime = this.intervalPS,
            startColor = col
        };
        this.psAlly.Emit(emitParams, 1);
    }
 
    // Token: 0x040018A0 RID: 6304
    public static WidgetMinimap Instance;
 
    // Token: 0x040018A1 RID: 6305
    public float interval;
 
    // Token: 0x040018A2 RID: 6306
    public float intervalPS;
 
    // Token: 0x040018A3 RID: 6307
    public float psSize;
 
    // Token: 0x040018A4 RID: 6308
    public RectTransform rectAll;
 
    // Token: 0x040018A5 RID: 6309
    public RectTransform rectMap;
 
    // Token: 0x040018A6 RID: 6310
    public Vector2 baseSize;
 
    // Token: 0x040018A7 RID: 6311
    private Point pos = new Point();
 
    // Token: 0x040018A8 RID: 6312
    public UIButton buttonMaptool;
 
    // Token: 0x040018A9 RID: 6313
    public UIMapPreview preview;
 
    // Token: 0x040018AA RID: 6314
    public Color colorAlly;
 
    // Token: 0x040018AB RID: 6315
    public Color colorEnemy;
 
    // Token: 0x040018AC RID: 6316
    public Color colorGuest;
 
    // Token: 0x040018AD RID: 6317
    public ParticleSystem psAlly;
 
    // Token: 0x040018AE RID: 6318
    public Transform transBound;
 
    // Token: 0x040018AF RID: 6319
    public Vector2 posPs;
 
    // Token: 0x040018B0 RID: 6320
    public Transform transCam;
 
    // Token: 0x040018B1 RID: 6321
    private Point point = new Point();
 
    // Token: 0x040018B2 RID: 6322
    private int count;
 
    // Token: 0x02000B97 RID: 2967
    public class Extra
    {
        // Token: 0x04002E77 RID: 11895
        public bool rotate;
 
        // Token: 0x04002E78 RID: 11896
        public bool monoColor;
 
        // Token: 0x04002E79 RID: 11897
        public bool limitBounds;
 
        // Token: 0x04002E7A RID: 11898
        public int alpha;
 
        // Token: 0x04002E7B RID: 11899
        public int scale;
 
        // Token: 0x04002E7C RID: 11900
        public int width;
    }
}