public void DrawMirrorOnFullscreenMap(int tileX, int tileY, bool isTarget)
        {
            Texture2D tex     = this.MirrorTex;
            float     myScale = isTarget ? 0.25f : 0.125f;
            float     uiScale = 5f;        //Main.mapFullscreenScale;
            float     scale   = uiScale * myScale;

            int wldBaseX = ((tileX + 1) << 4) + 8;
            int wldBaseY = ((tileY + 1) << 4) + 8;
            var wldPos   = new Vector2(wldBaseX, wldBaseY);

            Tuple <Vector2, bool> overMapData = HUDMapHelpers.GetFullMapScreenPosition(wldPos);

            if (overMapData.Item2)
            {
                Vector2 scrPos = overMapData.Item1;

                Main.spriteBatch.Draw(
                    texture: tex,
                    position: scrPos,
                    sourceRectangle: null,
                    color: isTarget ? Color.Cyan : Color.White,
                    rotation: 0f,
                    origin: new Vector2(tex.Width / 2, tex.Height / 2),
                    scale: scale,
                    effects: SpriteEffects.None,
                    layerDepth: 1f
                    );
            }
        }
        ////////////////

        public override void PostDrawFullscreenMap(ref string mouseText)
        {
            var myplayer = TmlHelpers.SafelyGetModPlayer <MMMPlayer>(Main.LocalPlayer);

            if (!myplayer.IsMapMirrorPicking)
            {
                return;
            }

            int maxDistSqr = MountedMagicMirrorsMod.MaxTileClickDistance * MountedMagicMirrorsMod.MaxTileClickDistance;

            int mouseX = Main.mouseX - (Main.screenWidth / 2);

            mouseX = (int)((float)mouseX * Main.UIScale);
            mouseX = (Main.screenWidth / 2) + mouseX;
            int mouseY = Main.mouseY - (Main.screenHeight / 2);

            mouseY = (int)((float)mouseY * Main.UIScale);
            mouseY = (Main.screenHeight / 2) + mouseY;

            (int x, int y)mouseTile;
            HUDMapHelpers.GetFullscreenMapTileOfScreenPosition(mouseX, mouseY, out mouseTile);

            int closestTileDistSqr = maxDistSqr;

            (int x, int y)closestTilePos = (0, 0);
            IEnumerable <(int, int)> discoveredMirrors = myplayer.GetDiscoveredMirrors().ToArray();

            foreach ((int tileX, int tileY) in discoveredMirrors)
            {
                int distX   = mouseTile.x - tileX;
                int distY   = mouseTile.y - tileY;
                int distSqr = (distX * distX) + (distY * distY);

                if (distSqr < closestTileDistSqr)
                {
                    closestTileDistSqr = distSqr;
                    closestTilePos     = (tileX, tileY);
                }
            }

            foreach ((int tileX, int tileY) in discoveredMirrors)
            {
                bool isTarget = tileX == closestTilePos.x &&
                                tileY == closestTilePos.y &&
                                closestTileDistSqr < maxDistSqr;

                if (isTarget)
                {
                    myplayer.TargetMirror = (tileX, tileY);
                }

                this.DrawMirrorOnFullscreenMap(tileX, tileY, isTarget);
            }

            if (closestTilePos == (0, 0))
            {
                myplayer.TargetMirror = null;
            }
        }
        public void DrawOverlayMap(WormholeLink link, SpriteBatch sb)
        {
            if (!link.IsCharted(Main.LocalPlayer) && !WormholesConfig.Instance.DebugModeMapCheat)
            {
                return;
            }

            float     scale = Main.mapOverlayScale / 1.5f;
            Texture2D tex   = WormholesUI.Tex;

            Rectangle lRect = new Rectangle((int)link.LeftPortal.Pos.X, (int)link.LeftPortal.Pos.Y, tex.Width, tex.Height);
            Rectangle rRect = new Rectangle((int)link.RightPortal.Pos.X, (int)link.RightPortal.Pos.Y, tex.Width, tex.Height);

            var lPosData = HUDMapHelpers.GetOverlayMapPositionAsScreenPosition(lRect);

            if (lPosData.IsOnScreen)
            {
                Color lColor = link.LeftPortal.BaseColor * Main.mapOverlayAlpha;
                sb.Draw(tex, (Vector2)lPosData.Item1, this.TexAnim.Frame, lColor, 0f, new Vector2(), scale, SpriteEffects.None, 1f);
            }

            var rPosData = HUDMapHelpers.GetOverlayMapPositionAsScreenPosition(rRect);

            if (rPosData.IsOnScreen)
            {
                Color rColor = link.RightPortal.BaseColor * Main.mapOverlayAlpha;
                sb.Draw(tex, rPosData.Item1, this.TexAnim.Frame, rColor, 0f, new Vector2(), scale, SpriteEffects.None, 1f);
            }
        }
        ////

        private void DrawAmbushOnFullscreenMap(int tileX, int tileY, Ambush ambush)
        {
            var wldPos      = new Vector2(tileX * 16, tileY * 16);
            var overMapData = HUDMapHelpers.GetFullMapScreenPosition(wldPos);

            if (overMapData.Item2)
            {
                Main.spriteBatch.DrawString(
                    Main.fontMouseText,
                    "X",
                    overMapData.Item1,
                    Color.Red
                    );
            }

            if (this.LatestMinibossWho != -1)
            {
                NPC npc = Main.npc[this.LatestMinibossWho];

                if (npc == null || !npc.active)
                {
                    this.LatestMinibossWho = -1;
                }
                else
                {
                    Tuple <Vector2, bool> minibossPosData = HUDMapHelpers.GetFullMapScreenPosition(npc.position);

                    if (minibossPosData.Item2)
                    {
                        Main.spriteBatch.DrawString(
                            Main.fontMouseText,
                            "X",
                            minibossPosData.Item1,
                            Color.Green
                            );
                    }
                }
            }
        }