//
// Copyright 2020 Electronic Arts Inc.
//
// The Command & Conquer Map Editor and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// The Command & Conquer Map Editor and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection

using MobiusEditor.Interface;
using MobiusEditor.Model;
using MobiusEditor.Utility;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Drawing.Text;
using System.Linq;
using System.Text;

namespace MobiusEditor.Render
{
    public class RenderInfo
    {
        // paint position, paint action, true if flat, sub-position.

        // This works in 'classic pixels'; 1/24th of a cell.
        public Point RenderBasePoint;
        public Action<Graphics> RenderAction { get; private set; }
        public int ZOrder { get; private set; }
        public ITechno RenderedObject { get; private set; }
        public bool IsRendered { get; set; }

        public RenderInfo(Point renderPosition, Action<Graphics> paintAction, int zOrder, ITechno paintedObject)
        {
            this.RenderBasePoint = renderPosition;
            this.RenderAction = paintAction;
            this.ZOrder = zOrder;
            this.RenderedObject = paintedObject;
            this.IsRendered = false;
        }

        public RenderInfo(Point renderPosition, Action<Graphics> paintAction, ITechno paintedObject)
            :this(renderPosition, paintAction, Globals.ZOrderDefault, paintedObject)
        {
        }
    }

    public static class MapRenderer
    {
        private static readonly int[] Facing16 = new int[256]
        {
            0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,
            2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,
            4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,
            6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,
            8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,
            10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,
            12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,
            14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,0,0,0,0,0,0,0,0
        };

        private static readonly int[] Facing32 = new int[256]
        {
            0,0,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,
            3,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,7,7,7,7,7,7,7,8,8,8,8,
            8,8,8,9,9,9,9,9,9,9,10,10,10,10,10,10,10,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,
            13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,
            16,16,16,16,16,17,17,17,17,17,17,17,17,17,18,18,18,18,18,18,18,18,18,19,19,19,19,19,19,19,19,19,
            19,20,20,20,20,20,20,21,21,21,21,21,21,21,22,22,22,22,22,22,22,23,23,23,23,23,23,23,24,24,24,24,
            24,24,24,25,25,25,25,25,25,25,26,26,26,26,26,26,26,27,27,27,27,27,27,27,28,28,28,28,28,28,28,28,
            29,29,29,29,29,29,29,29,30,30,30,30,30,30,30,30,30,31,31,31,31,31,31,31,31,31,0,0,0,0,0,0
        };

        private static readonly int[] HumanShape = new int[32]
        {
            0,0,7,7,7,7,6,6,6,6,5,5,5,5,5,4,4,4,3,3,3,3,2,2,2,2,1,1,1,1,1,0
        };

        private static readonly int[] BodyShape = new int[32]
        {
            0,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1
        };

        /// <summary>
        /// Cosine table. Technically signed bytes, but stored as 00-FF for simplicity.
        /// </summary>
        private static byte[] CosTable = {
            0x00, 0x03, 0x06, 0x09, 0x0c, 0x0f, 0x12, 0x15, 0x18, 0x1b, 0x1e, 0x21, 0x24, 0x27, 0x2a, 0x2d,
            0x30, 0x33, 0x36, 0x39, 0x3b, 0x3e, 0x41, 0x43, 0x46, 0x49, 0x4b, 0x4e, 0x50, 0x52, 0x55, 0x57,
            0x59, 0x5b, 0x5e, 0x60, 0x62, 0x64, 0x65, 0x67, 0x69, 0x6b, 0x6c, 0x6e, 0x6f, 0x71, 0x72, 0x74,
            0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7b, 0x7c, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,

            0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7c, 0x7b, 0x7b, 0x7a, 0x79, 0x78, 0x77, 0x76,
            0x75, 0x74, 0x72, 0x71, 0x70, 0x6e, 0x6c, 0x6b, 0x69, 0x67, 0x66, 0x64, 0x62, 0x60, 0x5e, 0x5b,
            0x59, 0x57, 0x55, 0x52, 0x50, 0x4e, 0x4b, 0x49, 0x46, 0x43, 0x41, 0x3e, 0x3b, 0x39, 0x36, 0x33,
            0x30, 0x2d, 0x2a, 0x27, 0x24, 0x21, 0x1e, 0x1b, 0x18, 0x15, 0x12, 0x0f, 0x0c, 0x09, 0x06, 0x03,

            0x00, 0xfd, 0xfa, 0xf7, 0xf4, 0xf1, 0xee, 0xeb, 0xe8, 0xe5, 0xe2, 0xdf, 0xdc, 0xd9, 0xd6, 0xd3,
            0xd0, 0xcd, 0xca, 0xc7, 0xc5, 0xc2, 0xbf, 0xbd, 0xba, 0xb7, 0xb5, 0xb2, 0xb0, 0xae, 0xab, 0xa9,
            0xa7, 0xa5, 0xa2, 0xa0, 0x9e, 0x9c, 0x9a, 0x99, 0x97, 0x95, 0x94, 0x92, 0x91, 0x8f, 0x8e, 0x8c,
            0x8b, 0x8a, 0x89, 0x88, 0x87, 0x86, 0x85, 0x85, 0x84, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82, 0x82,

            0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x83, 0x83, 0x84, 0x85, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
            0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x92, 0x94, 0x95, 0x97, 0x99, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa5,
            0xa7, 0xa9, 0xab, 0xae, 0xb0, 0xb2, 0xb5, 0xb7, 0xba, 0xbd, 0xbf, 0xc2, 0xc5, 0xc7, 0xca, 0xcd,
            0xd0, 0xd3, 0xd6, 0xd9, 0xdc, 0xdf, 0xe2, 0xe5, 0xe8, 0xeb, 0xee, 0xf1, 0xf4, 0xf7, 0xfa, 0xfd,
        };

        /// <summary>
        /// Sine table. Technically signed bytes, but stored as 00-FF for simplicity.
        /// </summary>
        private static byte[] SinTable = {
            0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7c, 0x7b, 0x7b, 0x7a, 0x79, 0x78, 0x77, 0x76,
            0x75, 0x74, 0x72, 0x71, 0x70, 0x6e, 0x6c, 0x6b, 0x69, 0x67, 0x66, 0x64, 0x62, 0x60, 0x5e, 0x5b,
            0x59, 0x57, 0x55, 0x52, 0x50, 0x4e, 0x4b, 0x49, 0x46, 0x43, 0x41, 0x3e, 0x3b, 0x39, 0x36, 0x33,
            0x30, 0x2d, 0x2a, 0x27, 0x24, 0x21, 0x1e, 0x1b, 0x18, 0x15, 0x12, 0x0f, 0x0c, 0x09, 0x06, 0x03,

            0x00, 0xfd, 0xfa, 0xf7, 0xf4, 0xf1, 0xee, 0xeb, 0xe8, 0xe5, 0xe2, 0xdf, 0xdc, 0xd9, 0xd6, 0xd3,
            0xd0, 0xcd, 0xca, 0xc7, 0xc5, 0xc2, 0xbf, 0xbd, 0xba, 0xb7, 0xb5, 0xb2, 0xb0, 0xae, 0xab, 0xa9,
            0xa7, 0xa5, 0xa2, 0xa0, 0x9e, 0x9c, 0x9a, 0x99, 0x97, 0x95, 0x94, 0x92, 0x91, 0x8f, 0x8e, 0x8c,
            0x8b, 0x8a, 0x89, 0x88, 0x87, 0x86, 0x85, 0x85, 0x84, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82, 0x82,

            0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x83, 0x83, 0x84, 0x85, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
            0x8b, 0x8c, 0x8e, 0x8f, 0x90, 0x92, 0x94, 0x95, 0x97, 0x99, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa5,
            0xa7, 0xa9, 0xab, 0xae, 0xb0, 0xb2, 0xb5, 0xb7, 0xba, 0xbd, 0xbf, 0xc2, 0xc5, 0xc7, 0xca, 0xcd,
            0xd0, 0xd3, 0xd6, 0xd9, 0xdc, 0xdf, 0xe2, 0xe5, 0xe8, 0xeb, 0xee, 0xf1, 0xf4, 0xf7, 0xfa, 0xfd,

            0x00, 0x03, 0x06, 0x09, 0x0c, 0x0f, 0x12, 0x15, 0x18, 0x1b, 0x1e, 0x21, 0x24, 0x27, 0x2a, 0x2d,
            0x30, 0x33, 0x36, 0x39, 0x3b, 0x3e, 0x41, 0x43, 0x46, 0x49, 0x4b, 0x4e, 0x50, 0x52, 0x55, 0x57,
            0x59, 0x5b, 0x5e, 0x60, 0x62, 0x64, 0x65, 0x67, 0x69, 0x6b, 0x6c, 0x6e, 0x6f, 0x71, 0x72, 0x74,
            0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7b, 0x7c, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
        };

        private static void MovePoint(ref int x, ref int y, byte dir, int distance, int perspectiveDivider)
        {
            x += ((sbyte)CosTable[dir] * distance) >> 7;
            y += -(((sbyte)SinTable[dir] * distance / perspectiveDivider) >> 7);
        }

        private static readonly short[] HeliDistanceAdjust = { 8, 9, 10, 9, 8, 9, 10, 9 };

        private static readonly Point[] BackTurretAdjust = new Point[]
        {
            new Point(1, 2),    // N
            new Point(-1, 1),
            new Point(-2, 0),
            new Point(-3, 0),
            new Point(-3, 1),   // NW
            new Point(-4, -1),
            new Point(-4, -1),
            new Point(-5, -2),
            new Point(-5, -3),  // W
            new Point(-5, -3),
            new Point(-3, -3),
            new Point(-3, -4),
            new Point(-3, -4),  // SW
            new Point(-3, -5),
            new Point(-2, -5),
            new Point(-1, -5),
            new Point(0, -5),   // S
            new Point(1, -6),
            new Point(2, -5),
            new Point(3, -5),
            new Point(4, -5),   // SE
            new Point(6, -4),
            new Point(6, -3),
            new Point(6, -3),
            new Point(6, -3),   // E
            new Point(5, -1),
            new Point(5, -1),
            new Point(4, 0),
            new Point(3, 0),    // NE
            new Point(2, 0),
            new Point(2, 1),
            new Point(1, 2)
        };

        public static void Render(GameInfo gameInfo, Map map, Graphics graphics, ISet<Point> locations, MapLayerFlag layers, double tileScale, ShapeCacheManager cacheManager)
        {
            bool disposeCacheManager = false;
            if (cacheManager == null)
            {
                cacheManager = new ShapeCacheManager();
                disposeCacheManager = true;
            }
            // tileScale should always be given so it results in an exact integer tile size. Math.Round was added to account for .999 situations in the floats.
            Size tileSize = new Size(Math.Max(1, (int)Math.Round(Globals.OriginalTileWidth * tileScale)), Math.Max(1, (int)Math.Round(Globals.OriginalTileHeight * tileScale)));
            //Size tileSize = new Size(Math.Max(1, (int)(Globals.OriginalTileWidth * tileScale)), Math.Max(1, (int)(Globals.OriginalTileHeight * tileScale)));
            TheaterType theater = map.Theater;
            // paint position, paint action, true if flat, sub-position.
            List<RenderInfo> overlappingRenderList = new List<RenderInfo>();
            Func<IEnumerable<Point>> renderLocations = null;
            if (locations != null)
            {
                renderLocations = () => locations.OrderBy(p => p.Y * map.Metrics.Width + p.X);
            }
            else
            {
                IEnumerable<Point> allCells()
                {
                    for (int y = 0; y < map.Metrics.Height; ++y)
                    {
                        for (int x = 0; x < map.Metrics.Width; ++x)
                        {
                            yield return new Point(x, y);
                        }
                    }
                }
                renderLocations = allCells;
            }
            CompositingQuality backupCompositingQuality = graphics.CompositingQuality;
            InterpolationMode backupInterpolationMode = graphics.InterpolationMode;
            SmoothingMode backupSmoothingMode = graphics.SmoothingMode;
            PixelOffsetMode backupPixelOffsetMode = graphics.PixelOffsetMode;
            // Check if high-quality tile resizing is useful.
            SetRenderSettings(graphics, false);
            bool isSmooth = backupCompositingQuality != graphics.CompositingQuality ||
                            backupInterpolationMode != graphics.InterpolationMode ||
                            backupSmoothingMode != graphics.SmoothingMode ||
                            backupPixelOffsetMode != graphics.PixelOffsetMode;
            // No need to restore the settings; the high quality tile resizing makes all tiles the
            // required size, and if isSmooth is false, the settings were already on pixel resize.
            if ((layers & MapLayerFlag.Template) != MapLayerFlag.None)
            {
                TemplateType clear = map.TemplateTypes.Where(t => t.Flag == TemplateTypeFlag.Clear).FirstOrDefault();
                foreach (Point topLeft in renderLocations())
                {
                    Template template = map.Templates[topLeft];
                    TemplateType ttype = template?.Type ?? clear;
                    string name = ttype.Name;
                    // For clear terrain, calculate icon from 0-15 using map position.
                    int icon = template?.Icon ?? ((topLeft.X & 0x03) | ((topLeft.Y) & 0x03) << 2);
                    // If something is actually placed on the map, show it, even if it has no graphics.
                    string tileName = "template_" + name + "_" + icon.ToString("D4") + "_" + tileSize.Width + "x" + tileSize.Height + (isSmooth ? "_smooth" : String.Empty);
                    Bitmap tileImg = cacheManager.GetImage(tileName);
                    Rectangle renderBounds = new Rectangle(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height, tileSize.Width, tileSize.Height);
                    if (tileImg == null)
                    {
                        bool success = Globals.TheTilesetManager.GetTileData(name, icon, out Tile tile, true, false);
                        if (tile != null && tile.Image != null)
                        {
                            Bitmap tileImage = tile.Image;
                            if (!isSmooth || (tileSize.Width == tileImage.Width && tileSize.Height == tileImage.Height))
                            {
                                tileImg = tileImage.RemoveAlpha();
                            }
                            else
                            {
                                // Results in a new image that is scaled to the correct size, without edge artifacts.
                                Bitmap scaledImage = tileImage.HighQualityScale(tileSize.Width, tileSize.Height,
                                        backupCompositingQuality, backupInterpolationMode, backupSmoothingMode, backupPixelOffsetMode);
                                scaledImage.RemoveAlphaOnCurrent();
                                tileImg = scaledImage;
                            }
                            cacheManager.AddImage(tileName, tileImg);
                            
                        }
                    }
                    if (tileImg != null)
                    {
                        graphics.DrawImage(tileImg, renderBounds);
                    }
                    else
                    {
                        Debug.Print(string.Format("Template {0} ({1}) could not be rendered.", name, icon));
                    }
                }
            }
            // Since high-quality scaling is now done on the tiles themselves, the actual map tile painting is done
            // with pixel interpolation mode because it is faster, and the tiles are already correctly sized anyway.
            // So now, restore the actual requested settings.
            graphics.CompositingQuality = backupCompositingQuality;
            graphics.InterpolationMode = backupInterpolationMode;
            graphics.SmoothingMode = backupSmoothingMode;
            graphics.PixelOffsetMode = backupPixelOffsetMode;
            // Attached bibs are counted under Buildings, not Smudge.
            if ((layers & MapLayerFlag.Buildings) != MapLayerFlag.None)
            {
                foreach (Point topLeft in renderLocations())
                {
                    Smudge smudge = map.Smudge[topLeft];
                    // Don't render bibs in theaters which don't contain them.
                    if (smudge != null && smudge.Type.IsAutoBib && (!Globals.FilterTheaterObjects || smudge.Type.ExistsInTheater))
                    {
                        RenderSmudge(topLeft, tileSize, tileScale, smudge, isSmooth, cacheManager).Item2(graphics);
                    }
                }
            }
            if ((layers & MapLayerFlag.Smudge) != MapLayerFlag.None)
            {
                foreach (Point topLeft in renderLocations())
                {
                    Smudge smudge = map.Smudge[topLeft];
                    if (smudge != null && !smudge.Type.IsAutoBib)
                    {
                        RenderSmudge(topLeft, tileSize, tileScale, smudge, isSmooth, cacheManager).Item2(graphics);
                    }
                }
            }
            if ((layers & MapLayerFlag.OverlayAll) != MapLayerFlag.None)
            {
                foreach (Point location in renderLocations())
                {
                    Overlay overlay = map.Overlay[location];
                    if (overlay == null)
                    {
                        continue;
                    }
                    if (Globals.CratesOnTop && overlay.Type.IsCrate && (layers & MapLayerFlag.Overlay) != MapLayerFlag.None)
                    {
                        // if "CratesOnTop" logic is active, crates are skipped here and painted afterwards.
                        continue;
                    }
                    bool paintAsWall = overlay.Type.IsWall && (layers & MapLayerFlag.Walls) != MapLayerFlag.None;
                    bool paintAsResource = overlay.Type.IsResource && (layers & MapLayerFlag.Resources) != MapLayerFlag.None;
                    bool paintAsOverlay = overlay.Type.IsOverlay && (layers & MapLayerFlag.Overlay) != MapLayerFlag.None;
                    if (paintAsWall || paintAsResource || paintAsOverlay)
                    {
                        RenderOverlay(gameInfo, location, map.Bounds, tileSize, tileScale, overlay, false).Item2(graphics);
                    }
                }
            }
            if ((layers & MapLayerFlag.Buildings) != MapLayerFlag.None)
            {
                foreach ((Point topLeft, Building building) in map.Buildings.OfType<Building>())
                {
                    if ((locations != null) && !locations.Contains(topLeft))
                    {
                        continue;
                    }
                    overlappingRenderList.Add(RenderBuilding(gameInfo, map, topLeft, tileSize, tileScale, building, false));
                }
            }
            if ((layers & MapLayerFlag.Infantry) != MapLayerFlag.None)
            {
                foreach ((Point topLeft, InfantryGroup infantryGroup) in map.Technos.OfType<InfantryGroup>())
                {
                    if ((locations != null) && !locations.Contains(topLeft))
                    {
                        continue;
                    }
                    foreach (InfantryStoppingType ist in InfantryGroup.RenderOrder)
                    {
                        Infantry infantry = infantryGroup.Infantry[(int)ist];
                        if (infantry == null)
                        {
                            continue;
                        }
                        overlappingRenderList.Add(RenderInfantry(topLeft, tileSize, infantry, ist, false));
                    }
                }
            }
            if ((layers & MapLayerFlag.Units) != MapLayerFlag.None)
            {
                foreach ((Point topLeft, Unit unit) in map.Technos.OfType<Unit>())
                {
                    if ((locations != null) && !locations.Contains(topLeft))
                    {
                        continue;
                    }
                    overlappingRenderList.Add(RenderUnit(gameInfo, topLeft, tileSize, unit, false));
                }
            }
            if ((layers & MapLayerFlag.Terrain) != MapLayerFlag.None)
            {
                foreach ((Point topLeft, Terrain terrain) in map.Technos.OfType<Terrain>())
                {
                    if ((locations != null) && !locations.Contains(topLeft))
                    {
                        continue;
                    }
                    overlappingRenderList.Add(RenderTerrain(topLeft, tileSize, tileScale, terrain, false));
                }
            }
            // Paint all the rest
            List<RenderInfo> validRenders = overlappingRenderList.Where(obj => obj.RenderedObject != null).ToList();
            int paintOrder = 0;
            foreach (RenderInfo info in validRenders.OrderBy(obj => obj.ZOrder).ThenBy(obj => obj.RenderBasePoint.Y).ThenByDescending(obj => obj.RenderBasePoint.X))
            {
                info.RenderAction(graphics);
                info.RenderedObject.DrawOrderCache = paintOrder++;
            }
            if (Globals.CratesOnTop && (layers & MapLayerFlag.Overlay) != MapLayerFlag.None)
            {
                foreach (Point topLeft in renderLocations())
                {
                    Overlay overlay = map.Overlay[topLeft];
                    if (overlay == null || !overlay.Type.IsCrate)
                    {
                        continue;
                    }
                    RenderOverlay(gameInfo, topLeft, map.Bounds, tileSize, tileScale, overlay, false).Item2(graphics);
                }
            }

            if ((layers & MapLayerFlag.Waypoints) != MapLayerFlag.None)
            {
                // todo avoid overlapping waypoints of the same type?
                Dictionary<int, int> flagOverlapPoints = new Dictionary<int, int>();
                HashSet<int> handledPoints = new HashSet<int>();
                ITeamColor[] flagColors = map.FlagColors;
                bool soloMission = map.BasicSection.SoloMission;
                bool previewIsFlag = map.Waypoints.Where(w => w.IsPreview && Waypoint.GetMpIdFromFlag(w.Flag) != -1).Any();
                int lastFlag = -1;
                float wpAlpha = 0.5f;
                if (!soloMission)
                {
                    int firstFlag = -1;
                    for (int i = 0; i < map.Waypoints.Length; i++)
                    {
                        Waypoint waypoint = map.Waypoints[i];
                        if (waypoint.IsPreview)
                        {
                            continue;
                        }
                        int mpId = Waypoint.GetMpIdFromFlag(map.Waypoints[i].Flag);
                        if (mpId != -1)
                        {
                            if (firstFlag == -1)
                            {
                                firstFlag = i;
                            }
                            lastFlag = i;
                        }
                    }
                    // This logic is kind of dirty; it relies on all flag points being in consecutive order. But without that, the preview logic doesn't work.
                    for (int i = 0; i < firstFlag; i++)
                    {
                        Waypoint waypoint = map.Waypoints[i];
                        if (!waypoint.Point.HasValue || (locations != null && !locations.Contains(waypoint.Point.Value))
                            || !map.Metrics.GetCell(waypoint.Point.Value, out int cell) || handledPoints.Contains(cell))
                        {
                            continue;
                        }
                        handledPoints.Add(cell);
                        RenderWaypoint(gameInfo, soloMission, tileSize, flagColors, waypoint, wpAlpha, 0, cacheManager).Item2(graphics);
                    }
                    RenderWaypointFlags(graphics, gameInfo, map, map.Metrics.Bounds, tileSize, cacheManager);
                }
                for (int i = lastFlag + 1; i < map.Waypoints.Length; i++)
                {
                    Waypoint waypoint = map.Waypoints[i];
                    if (!waypoint.Point.HasValue || (locations != null && !locations.Contains(waypoint.Point.Value))
                        || !map.Metrics.GetCell(waypoint.Point.Value, out int cell) || handledPoints.Contains(cell))
                    {
                        continue;
                    }
                    handledPoints.Add(cell);
                    RenderWaypoint(gameInfo, soloMission, tileSize, flagColors, waypoint, wpAlpha, 0, cacheManager).Item2(graphics);
                }
            }
            if (disposeCacheManager)
            {
                cacheManager.Reset();
            }
        }

        public static void Render(GameInfo gameInfo, Map map, Graphics graphics, ISet<Point> locations, MapLayerFlag layers)
        {
            Render(gameInfo, map, graphics, locations, layers, Globals.MapTileScale, Globals.TheShapeCacheManager);
        }

        public static (Rectangle, Action<Graphics>) RenderSmudge(Point topLeft, Size tileSize, double tileScale, Smudge smudge, bool isSmoothRendering, ShapeCacheManager cacheManager)
        {
            if (Globals.FilterTheaterObjects && !smudge.Type.ExistsInTheater)
            {
                Debug.Print(string.Format("Smudge {0} ({1}) not available in this theater.", smudge.Type.Name, smudge.Icon));
                return (Rectangle.Empty, (g) => { });
            }
            float alphaFactor = 1.0f;
            Building bld = smudge.AttachedTo;
            if (bld != null)
            {
                if (bld.IsPreview)
                {
                    alphaFactor = Globals.PreviewAlphaFloat;
                }
                if (!bld.IsPrebuilt)
                {
                    alphaFactor *= Globals.UnbuiltAlphaFloat;
                }
            }
            else if (smudge.IsPreview)
            {
                alphaFactor = Globals.PreviewAlphaFloat;
            }
            alphaFactor = alphaFactor.Restrict(0, 1);
            string tileName = "smudge_" + smudge.Type.Name + "_" + smudge.Icon.ToString("D4") + "_" + tileSize.Width + "x" + tileSize.Height + (isSmoothRendering ? "_smooth" : String.Empty);
            Bitmap tileImg = cacheManager.GetImage(tileName);
            if (tileImg == null)
            {
                bool success = Globals.TheTilesetManager.GetTileData(smudge.Type.Name, smudge.Icon, out Tile tile, true, false);
                if (tile != null && tile.Image != null)
                {
                    Bitmap tileImage = tile.Image;
                    // Check if high-quality tile resizing is useful.
                    if (!isSmoothRendering || (tileSize.Width == tileImage.Width && tileSize.Height == tileImage.Height))
                    {
                        tileImg = new Bitmap(tileSize.Width, tileSize.Height);
                        Rectangle smudgeBounds = RenderBounds(tile.Image.Size, new Size(1, 1), tileScale);
                        using (Graphics g = Graphics.FromImage(tileImg))
                        {
                            SetRenderSettings(g, isSmoothRendering);
                            g.DrawImage(tileImage, smudgeBounds, new Rectangle(0, 0, tileImage.Width, tileImage.Height), GraphicsUnit.Pixel);
                        }
                    }
                    else
                    {
                        // Results in a new image that is scaled to the correct size, without edge artifacts.
                        tileImg = tileImage.HighQualityScale(tileSize.Width, tileSize.Height);
                    }
                    cacheManager.AddImage(tileName, tileImg);
                    
                }
            }
            if (tileImg != null)
            {
                Rectangle smudgeBounds = new Rectangle(
                    (tileSize.Width - tileImg.Width) / 2,
                    (tileSize.Height - tileImg.Height) / 2,
                    tileImg.Width, tileImg.Height);
                smudgeBounds.X += topLeft.X * tileSize.Width;
                smudgeBounds.Y += topLeft.Y * tileSize.Height;
                void render(Graphics g)
                {
                    using (ImageAttributes imageAttributes = new ImageAttributes())
                    {
                        imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, alphaFactor));
                        g.DrawImage(tileImg, smudgeBounds, 0, 0, tileImg.Width, tileImg.Height, GraphicsUnit.Pixel, imageAttributes);
                    }
                }
                return (smudgeBounds, render);
            }
            else
            {
                Debug.Print(string.Format("Smudge {0} ({1}) not found", smudge.Type.Name, smudge.Icon));
                return (Rectangle.Empty, (g) => { });
            }
        }

        public static (Rectangle, Action<Graphics>) RenderOverlay(GameInfo gameInfo, Point topLeft, Rectangle? mapBounds, Size tileSize, double tileScale, Overlay overlay, bool fullOpaque)
        {
            OverlayType ovtype = overlay.Type;
            string name = ovtype.GraphicsSource;
            int icon = ovtype.IsConcrete || ovtype.IsResource || ovtype.IsWall || ovtype.ForceTileNr == -1 ? overlay.Icon : ovtype.ForceTileNr;
            bool isTeleport = gameInfo != null && gameInfo.GameType == GameType.SoleSurvivor && ovtype == SoleSurvivor.OverlayTypes.Teleport && Globals.AdjustSoleTeleports;
            bool success = Globals.TheTilesetManager.GetTileData(name, icon, out Tile tile, true, false);
            if (tile != null && tile.Image != null)
            {
                int actualTopLeftX = topLeft.X * tileSize.Width;
                int actualTopLeftY = topLeft.Y * tileSize.Height;
                Rectangle overlayBounds = RenderBounds(tile.Image.Size, new Size(1, 1), tileScale);
                overlayBounds.X += actualTopLeftX;
                overlayBounds.Y += actualTopLeftY;
                float alphaFactor = 1.0f;
                if (!fullOpaque && overlay.IsPreview)
                {
                    alphaFactor = Globals.PreviewAlphaFloat;
                }
                Color tint = Color.White;
                if (overlay.Type.IsResource && mapBounds.HasValue && !mapBounds.Value.Contains(topLeft))
                {
                    tint = Color.FromArgb(0xFF, 0x80, 0x80);
                    // Technically the multiplication isn't needed; resources have no preview state in the editor.
                    if (!fullOpaque)
                    {
                        alphaFactor *= 0.7f;
                    }
                }
                alphaFactor = alphaFactor.Restrict(0, 1);
                void render(Graphics g)
                {
                    using (ImageAttributes imageAttributes = new ImageAttributes())
                    {
                        imageAttributes.SetColorMatrix(GetColorMatrix(tint, 1.0f, alphaFactor));
                        g.DrawImage(tile.Image, overlayBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
                        if (isTeleport)
                        {
                            // Transform ROAD tile into the teleport from SS.
                            int blackBorderX = Math.Max(1, tileSize.Width / 24);
                            int blackBorderY = Math.Max(1, tileSize.Height / 24);
                            int blueWidth = tileSize.Width - blackBorderX * 2;
                            int blueHeight = tileSize.Height - blackBorderY * 2;
                            int blackWidth = tileSize.Width - blackBorderX * 4;
                            int blackHeight = tileSize.Height - blackBorderY * 4;
                            using (SolidBrush blue = new SolidBrush(Color.FromArgb(92, 164, 200)))
                            using (SolidBrush black = new SolidBrush(Color.Black))
                            {
                                g.FillRectangle(blue, actualTopLeftX + blackBorderX, actualTopLeftY + blackBorderY, blueWidth, blueHeight);
                                g.FillRectangle(black, actualTopLeftX + blackBorderX * 2, actualTopLeftY + blackBorderY * 2, blackWidth, blackHeight);
                            }
                        }
                    }
                }
                return (overlayBounds, render);
            }
            else
            {
                Debug.Print(string.Format("Overlay {0} ({1}) not found", name, icon));
                return (Rectangle.Empty, (g) => { });
            }
        }

        public static RenderInfo RenderTerrain(Point topLeft, Size tileSize, double tileScale, Terrain terrain, bool fullOpaque)
        {
            TerrainType type = terrain.Type;
            string tileName = type.GraphicsSource;
            bool succeeded = Globals.TheTilesetManager.GetTileData(tileName, type.DisplayIcon, out Tile tile, true, false);
            terrain.DrawFrameCache = type.DisplayIcon;
            if (!succeeded && !string.Equals(type.GraphicsSource, type.Name, StringComparison.InvariantCultureIgnoreCase))
            {
                succeeded = Globals.TheTilesetManager.GetTileData(type.Name, type.DisplayIcon, out tile, true, false);
            }
            float alphaFactor = 1.0f;
            if (!fullOpaque)
            {
                if (terrain.IsPreview)
                {
                    alphaFactor *= Globals.PreviewAlphaFloat;
                }
                alphaFactor = alphaFactor.Restrict(0, 1);
            }
            Size terrTSize = type.Size;
            Size tileISize = tile.Image.Size;
            Point location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
            Size maxSize = new Size(terrTSize.Width * tileSize.Width, terrTSize.Height * tileSize.Height);
            Rectangle paintBounds;
            if (!succeeded)
            {
                // Stretch dummy graphics over the whole size.
                paintBounds = new Rectangle(0, 0, (int)Math.Round(terrTSize.Width * tileISize.Width * tileScale), (int)Math.Round(terrTSize.Height * tileISize.Height * tileScale));
            }
            else
            {
                paintBounds = RenderBounds(tileISize, terrTSize, tileScale);
            }
            paintBounds.X += location.X;
            paintBounds.Y += location.Y;
            void render(Graphics g)
            {
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, alphaFactor));
                    g.DrawImage(tile.Image, paintBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
                }
            }
            Point centerPoint = GetTerrainRenderPoint(terrain);
            Point usedCenter = new Point(topLeft.X * Globals.PixelWidth + centerPoint.X, topLeft.Y * Globals.PixelHeight + centerPoint.Y);
            return new RenderInfo(usedCenter, render, terrain);
        }

        public static RenderInfo RenderBuilding(GameInfo gameInfo, Map map, Point topLeft, Size tileSize, double tileScale, Building building, bool fullOpaque)
        {
            float alphaFactor = 1.0f;
            if (!fullOpaque)
            {
                if (building.IsPreview)
                {
                    alphaFactor *= Globals.PreviewAlphaFloat;
                }
                if (!building.IsPrebuilt)
                {
                    alphaFactor *= Globals.UnbuiltAlphaFloat;
                }
                alphaFactor = alphaFactor.Restrict(0, 1);
            }
            int icon = building.Type.FrameOffset;
            int maxIcon = 0;
            int damageIconOffs = 0;
            int collapseIcon = 0;
            // In TD, damage is when BELOW the threshold. In RA, it's ON the threshold.
            int healthyMin = gameInfo.HitPointsGreenMinimum;
            bool isDamaged = building.Strength <= healthyMin;
            bool hasCollapseFrame = false;
            // Only fetch if damaged. BuildingType.IsSingleFrame is an override for the RA mines. Everything else works with one simple logic.
            if (isDamaged && !building.Type.IsSingleFrame && !building.Type.IsWall)
            {
                maxIcon = Globals.TheTilesetManager.GetTileDataLength(building.Type.GraphicsSource);
                hasCollapseFrame = maxIcon > 1 && maxIcon % 2 == 1;
                damageIconOffs = (maxIcon + (hasCollapseFrame ? 0 : 1)) / 2;
                collapseIcon = maxIcon - 1;
            }
            if (building.Type.HasTurret)
            {
                icon += BodyShape[Facing32[building.Direction.ID]];
                if (isDamaged)
                {
                    icon += damageIconOffs;
                }
            }
            else if (building.Type.IsWall)
            {
                icon += GetBuildingOverlayIcon(map, topLeft, building);
            }
            else
            {
                if (building.Strength <= 1 && hasCollapseFrame)
                {
                    icon = collapseIcon;
                }
                else if (isDamaged)
                {
                    icon += damageIconOffs;
                }
            }
            ITeamColor teamColor = building.Type.CanRemap ? Globals.TheTeamColorManager[building.House?.BuildingTeamColor] : null;
            bool succeeded = Globals.TheTilesetManager.GetTeamColorTileData(building.Type.GraphicsSource, icon, teamColor, out Tile tile, true, false);
            building.DrawFrameCache = icon;
            Point location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
            Size maxSize = new Size(building.Type.Size.Width * tileSize.Width, building.Type.Size.Height * tileSize.Height);

            Size bldTSize = building.Type.Size;
            Size tileISize = tile.Image.Size;
            Rectangle paintBounds;
            if (!succeeded)
            {
                // Stretch dummy graphics over the whole size.
                paintBounds = new Rectangle(0, 0, maxSize.Width, maxSize.Height);
            }
            else
            {
                paintBounds = RenderBounds(tileISize, bldTSize, tileScale);
            }
            Rectangle buildingBounds = new Rectangle(location, maxSize);
            Tile factoryOverlayTile = null;
            // Draw no factory overlay over the collapse frame.
            if (building.Type.FactoryOverlay != null && (building.Strength > 1 || !hasCollapseFrame))
            {
                int overlayIcon = 0;
                if (building.Strength <= healthyMin)
                {
                    int maxOverlayIcon = Globals.TheTilesetManager.GetTileDataLength(building.Type.FactoryOverlay);
                    overlayIcon = maxOverlayIcon / 2;
                }
                Globals.TheTilesetManager.GetTeamColorTileData(building.Type.FactoryOverlay, overlayIcon, Globals.TheTeamColorManager[building.House?.BuildingTeamColor], out factoryOverlayTile);
            }
            void render(Graphics g)
            {
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, alphaFactor));
                    if (factoryOverlayTile != null)
                    {
                        // Avoid factory overlay showing as semitransparent.
                        using (Bitmap factory = new Bitmap(maxSize.Width, maxSize.Height))
                        {
                            factory.SetResolution(96, 96);
                            using (Graphics factoryG = Graphics.FromImage(factory))
                            {
                                factoryG.CopyRenderSettingsFrom(g);
                                Size renderSize = tileISize;
                                if (!succeeded)
                                {
                                    renderSize.Width = building.Type.Size.Width * tileSize.Width;
                                    renderSize.Height = building.Type.Size.Height * tileSize.Height;
                                }
                                Rectangle factBounds = RenderBounds(renderSize, building.Type.Size, tileScale);
                                Rectangle ovrlBounds = RenderBounds(factoryOverlayTile.Image.Size, building.Type.Size, tileScale);
                                factoryG.DrawImage(tile.Image, factBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel);
                                factoryG.DrawImage(factoryOverlayTile.Image, ovrlBounds, 0, 0, factoryOverlayTile.Image.Width, factoryOverlayTile.Image.Height, GraphicsUnit.Pixel);
                            }
                            g.DrawImage(factory, buildingBounds, 0, 0, factory.Width, factory.Height, GraphicsUnit.Pixel, imageAttributes);
                        }
                    }
                    else
                    {
                        paintBounds.X += location.X;
                        paintBounds.Y += location.Y;
                        g.DrawImage(tile.Image, paintBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
                    }
                }
            }
            Point centerPoint = GetBuildingRenderPoint(building);
            Point usedCenter = new Point(topLeft.X * Globals.PixelWidth + centerPoint.X, topLeft.Y * Globals.PixelHeight + centerPoint.Y);
            // "Z-Order" is for sorting buildings as floor level (0), flat on the floor (5), or sticking out of the floor (default; 10).
            // It determines whether pieces on unoccupied cells should overlap objects on these cells or be drawn below them.
            return new RenderInfo(usedCenter, render, building.Type.ZOrder, building);
        }

        private static int GetBuildingOverlayIcon(Map map, Point topLeft, Building building)
        {
            if (!building.Type.IsWall || map == null)
            {
                return 0;
            }
            BuildingType bt = building.Type;

            bool hasNorthWall = (map.Metrics.Adjacent(topLeft, FacingType.North, out Point north) ? map.Buildings[north] as Building : null)?.Type == bt;
            bool hasEastWall = (map.Metrics.Adjacent(topLeft, FacingType.East, out Point east) ? map.Buildings[east] as Building : null)?.Type == bt;
            bool hasSouthWall = (map.Metrics.Adjacent(topLeft, FacingType.South, out Point south) ? map.Buildings[south] as Building : null)?.Type == bt;
            bool hasWestWall = (map.Metrics.Adjacent(topLeft, FacingType.West, out Point west) ? map.Buildings[west] as Building : null)?.Type == bt;

            string btName = bt.Name;
            hasNorthWall |= map.Overlay.Adjacent(topLeft, FacingType.North)?.Type.Name == btName;
            hasEastWall |= map.Overlay.Adjacent(topLeft, FacingType.East)?.Type.Name == btName;
            hasSouthWall |= map.Overlay.Adjacent(topLeft, FacingType.South)?.Type.Name == btName;
            hasWestWall |= map.Overlay.Adjacent(topLeft, FacingType.West)?.Type.Name == btName;
            int icon = 0;
            if (hasNorthWall)
            {
                icon |= 1;
            }
            if (hasEastWall)
            {
                icon |= 2;
            }
            if (hasSouthWall)
            {
                icon |= 4;
            }
            if (hasWestWall)
            {
                icon |= 8;
            }
            return icon;
        }

        public static RenderInfo RenderInfantry(Point topLeft, Size tileSize, Infantry infantry, InfantryStoppingType infantryStoppingType, bool fullOpaque)
        {
            int icon = HumanShape[Facing32[infantry.Direction.ID]];
            ITeamColor teamColor = infantry.Type.CanRemap ? Globals.TheTeamColorManager[infantry.House?.UnitTeamColor] : null;
            Tile tile = null;
            // InfantryType.Init() should have taken care of RA's classic civilian remap mess at this point, and remapped all cached source graphics.
            bool success = Globals.TheTilesetManager.GetTeamColorTileData(infantry.Type.GraphicsSource, icon, teamColor, out tile, true, false);
            if (tile == null || tile.Image == null)
            {
                Debug.Print(string.Format("Infantry {0} graphics ({1}, frame {2}) not found", infantry.Type.Name, infantry.Type.GraphicsSource, icon));
                return new RenderInfo(Point.Empty, (g) => { }, infantry);
            }
            Size imSize = tile.Image.Size;
            Point origLocation = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
            Point renderLocation = origLocation;
            Point offset;
            // Offset is calculated as "pixels" in the old 24-pixel cells.
            Size renderSize;
            if (success)
            {
                // Actual graphics: get tweaked positions accounting for the shape of the infantry and the fact the theoretical positions are at their feet.
                offset = GetInfantryRenderPoint(infantryStoppingType);
                Point offsetActual = new Point(offset.X * tileSize.Width / Globals.PixelWidth, offset.Y * tileSize.Height / Globals.PixelHeight);
                renderLocation.Offset(offsetActual);
                renderSize = new Size(imSize.Width * tileSize.Width / Globals.OriginalTileWidth, imSize.Height * tileSize.Height / Globals.OriginalTileHeight);
            }
            else
            {
                // Dummy graphics: use theoretical positions.
                offset = InfantryGroup.RenderPosition(infantryStoppingType, false);
                Point offsetActual = new Point(offset.X * tileSize.Width / Globals.PixelWidth, offset.Y * tileSize.Height / Globals.PixelHeight);
                renderLocation.Offset(offsetActual);
                renderSize = new Size(imSize.Width * tileSize.Width / Globals.OriginalTileWidth, imSize.Height * tileSize.Height / Globals.OriginalTileHeight);
                renderSize.Width /= 3;
                renderSize.Height /= 2;
            }
            Rectangle renderBounds = new Rectangle(renderLocation - new Size(renderSize.Width / 2, renderSize.Height / 2), renderSize);
            float alphaFactor = 1.0f;
            if (!fullOpaque)
            {
                if (infantry.IsPreview)
                {
                    alphaFactor *= Globals.PreviewAlphaFloat;
                }
                alphaFactor = alphaFactor.Restrict(0, 1);
            }
            void render(Graphics g)
            {
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, alphaFactor));
                    g.DrawImage(tile.Image, renderBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
                    // Test code to visualise original 5-point die face location (green), and corrected infantry base point (feet) location (red).
                    /*/
                    Size pixel = new Size(tileSize.Width / Globals.PixelWidth, tileSize.Height / Globals.PixelHeight);
                    using (SolidBrush sb = new SolidBrush(Color.Red))
                    {
                        g.FillRectangle(sb, new Rectangle(renderLocation, pixel));
                    }
                    using (SolidBrush sb = new SolidBrush(Color.LimeGreen))
                    {
                        g.FillRectangle(sb, new Rectangle(new Point(
                            origLocation.X + offsetBare.X * tileSize.Width / Globals.PixelWidth,
                            origLocation.Y + (offsetBare.Y * tileSize.Height / Globals.PixelHeight)), pixel));
                    }
                    //*/
                }
            }
            // Render position is the feet point, adjusted to 24-pixel cell location.
            return new RenderInfo(new Point(topLeft.X * Globals.PixelWidth + offset.X, topLeft.Y * Globals.PixelHeight + offset.Y), render, infantry);
        }

        public static RenderInfo RenderUnit(GameInfo gameInfo, Point topLeft, Size tileSize, Unit unit, bool fullOpaque)
        {
            int icon = 0;
            int bodyFrames = 0;
            // In TD, damage is when BELOW the threshold. In RA, it's ON the threshold.
            int healthyMin = gameInfo.HitPointsGreenMinimum;
            int damagedMin = gameInfo.HitPointsYellowMinimum;
            FrameUsage frameUsage = unit.Type.BodyFrameUsage;
            if (frameUsage.HasFlag(FrameUsage.Frames01Single))
            {
                icon = 0;
                // Not actually determined, but whatever. Single frame units generally have no turret.
                bodyFrames = 1;
            }
            else if (frameUsage.HasFlag(FrameUsage.Frames08Cardinal))
            {
                icon = ((BodyShape[Facing32[unit.Direction.ID]] + 2) / 4) & 0x07;
                bodyFrames = 8;
            }
            else if (frameUsage.HasFlag(FrameUsage.Frames16Simple))
            {
                icon = BodyShape[Facing16[unit.Direction.ID] * 2] / 2;
                bodyFrames = 16;
            }
            else if (frameUsage.HasFlag(FrameUsage.Frames16Symmetrical))
            {
                // Special case for 16-frame rotation saved as 8-frame because it is symmetrical and thus the second half of the frames is the same.
                icon = (BodyShape[Facing32[unit.Direction.ID]] / 2) & 0x07;
                bodyFrames = 8;
            }
            else if (frameUsage.HasFlag(FrameUsage.Frames32Full) || !frameUsage.HasAnyFlags(FrameUsage.FrameUsages))
            {
                icon = BodyShape[Facing32[unit.Direction.ID]];
                bodyFrames = 32;
            }
            // Special logic for TD gunboat's damaged states.
            // East facing is not actually possible to set in missions. This is just the turret facing.
            if (frameUsage.HasFlag(FrameUsage.DamageStates))
            {
                if (unit.Strength <= healthyMin)
                    icon += bodyFrames;
                if (unit.Strength <= damagedMin)
                    icon += bodyFrames;
                // Skip three-step damaged frames. In practice this will just go to the east-facing ones though.
                bodyFrames *= 3;
            }
            // Special logic for APC-types with unload frames.
            if ((frameUsage & FrameUsage.HasUnloadFrames) != FrameUsage.None)
            {
                if (unit.Type.IsAircraft)
                {
                    // Transport heli unload has 4 frames
                    bodyFrames += 4;
                }
                else if (unit.Type.IsVessel)
                {
                    // Boat unload has 4 frames
                    bodyFrames += 4;
                }
                else
                {
                    // APC unload has 6 frames.
                    bodyFrames += 6;
                }
            }
            // Get House color.
            ITeamColor teamColor = null;
            if (unit.House != null && unit.Type.CanRemap)
            {
                string teamColorName;
                if (!unit.House.OverrideTeamColors.TryGetValue(unit.Type.Name, out teamColorName))
                {
                    teamColorName = unit.House?.UnitTeamColor;
                }
                teamColor = Globals.TheTeamColorManager[teamColorName];
            }
            // Get body frame
            Globals.TheTilesetManager.GetTeamColorTileData(unit.Type.Name, icon, teamColor, out Tile tile, true, false);
            unit.DrawFrameCache = icon;
            if (tile == null || tile.Image == null)
            {
                Debug.Print(string.Format("Unit {0} ({1}) not found", unit.Type.Name, icon));
                return new RenderInfo(Point.Empty, (g) => { }, null);
            }
            Size imSize = tile.Image.Size;
            Point location =
                new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height) +
                new Size(tileSize.Width / 2, tileSize.Height / 2);
            Size renderSize = new Size(imSize.Width * tileSize.Width / Globals.OriginalTileWidth, imSize.Height * tileSize.Height / Globals.OriginalTileHeight);
            Rectangle renderRect = new Rectangle(new Point(0, 0), renderSize);
            Rectangle renderBounds = new Rectangle(location - new Size(renderSize.Width / 2, renderSize.Height / 2), renderSize);
            // Turret handling
            Tile turretTile = null;
            Tile turret2Tile = null;
            Point turretAdjust = Point.Empty;
            Point turret2Adjust = Point.Empty;
            if (unit.Type.HasTurret)
            {
                FrameUsage turrUsage = unit.Type.TurretFrameUsage;
                string turretName = unit.Type.Turret ?? unit.Type.Name;
                string turret2Name = unit.Type.HasDoubleTurret ? unit.Type.SecondTurret ?? unit.Type.Turret ?? unit.Type.Name : null;
                int turret1Icon = 0;
                int turret2Icon = 0;
                if ((turrUsage & FrameUsage.Frames01Single) != FrameUsage.None)
                {
                    turret1Icon = 0;
                    turret2Icon = 0;
                }
                else if ((turrUsage & FrameUsage.Frames08Cardinal) != FrameUsage.None)
                {
                    // Never used for a turret, but whatever.
                    turret1Icon = ((BodyShape[Facing32[unit.Direction.ID]] + 2) / 4) & 0x07;
                    turret2Icon = turret1Icon;
                }
                else if ((turrUsage & FrameUsage.Frames16Simple) != FrameUsage.None)
                {
                    turret1Icon = BodyShape[Facing16[unit.Direction.ID] * 2] / 2;
                    turret2Icon = turret1Icon;
                }
                else if ((turrUsage & FrameUsage.Frames16Symmetrical) != FrameUsage.None)
                {
                    // Special case for 16-frame rotation saved as 8-frame because it is symmetrical and thus the second half of the frames is the same (MGG)
                    turret1Icon = (BodyShape[Facing32[unit.Direction.ID]] / 2) & 7;
                    turret2Icon = turret1Icon;
                }
                else if ((turrUsage & FrameUsage.Frames32Full) != FrameUsage.None)
                {
                    turret1Icon = BodyShape[Facing32[unit.Direction.ID]];
                    turret2Icon = turret1Icon;
                }
                else if ((turrUsage & FrameUsage.Rotor) != FrameUsage.None)
                {
                    turret1Icon = (unit.Direction.ID >> 5) % 2 == 1 ? 9 : 5;
                    turret2Icon = (unit.Direction.ID >> 5) % 2 == 1 ? 8 : 4;
                }
                // If same as body name, add body frames.
                turret1Icon = unit.Type.Name.Equals(turretName, StringComparison.OrdinalIgnoreCase) ? bodyFrames + turret1Icon : turret1Icon;
                turret2Icon = unit.Type.Name.Equals(turret2Name, StringComparison.OrdinalIgnoreCase) ? bodyFrames + turret2Icon : turret2Icon;
                if (turretName != null)
                    Globals.TheTilesetManager.GetTeamColorTileData(turretName, turret1Icon, teamColor, out turretTile, false, false);
                if (turret2Name != null)
                    Globals.TheTilesetManager.GetTeamColorTileData(turret2Name, turret2Icon, teamColor, out turret2Tile, false, false);
                // Flatbed is a special case; if it is used, TurretOffset is ignored.
                if (turrUsage.HasFlag(FrameUsage.OnFlatBed))
                {
                    // OnFlatBed indicates the turret oFfset is determined by the BackTurretAdjust table.
                    turretAdjust = BackTurretAdjust[Facing32[unit.Direction.ID]];
                    // Never actually used for 2 turrets. Put second turret in the front?
                    turret2Adjust = BackTurretAdjust[Facing32[(byte)((unit.Direction.ID + DirectionTypes.South.ID) & 0xFF)]];
                }
                else if (unit.Type.TurretOffset != 0)
                {
                    // Used by ships and by the transport helicopter.
                    int distance = unit.Type.TurretOffset;
                    int face = (unit.Direction.ID >> 5) & 7;
                    if (turrUsage.HasFlag(FrameUsage.Rotor))
                    {
                        // Rotor stretch distance is given by a table.
                        distance *= HeliDistanceAdjust[face];
                    }
                    int x = 0;
                    int y = 0;
                    // For vessels, perspective stretch is simply done as '/ 2'.
                    int perspectiveDivide = unit.Type.IsVessel ? 2 : 1;
                    MovePoint(ref x, ref y, unit.Direction.ID, distance, perspectiveDivide);
                    turretAdjust.X += x;
                    turretAdjust.Y += y;
                    if (unit.Type.HasDoubleTurret)
                    {
                        x = 0;
                        y = 0;
                        MovePoint(ref x, ref y, (byte)((unit.Direction.ID + DirectionTypes.South.ID) & 0xFF), distance, perspectiveDivide);
                        turret2Adjust.X += x;
                        turret2Adjust.Y += y;
                    }
                }
                // Adjust Y-offset.
                turretAdjust.Y += unit.Type.TurretY;
                turret2Adjust.Y += unit.Type.TurretY;
            }
            float alphaFactor = 1.0f;
            if (!fullOpaque)
            {
                if (unit.IsPreview)
                {
                    alphaFactor *= Globals.PreviewAlphaFloat;
                }
                alphaFactor = alphaFactor.Restrict(0, 1);
            }
            void render(Graphics g)
            {
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, alphaFactor));
                    // Combine body and turret to one image, then paint it. This is done because it might be semitransparent.
                    using (Bitmap unitBm = new Bitmap(renderBounds.Width, renderBounds.Height))
                    {
                        unitBm.SetResolution(96, 96);
                        using (Graphics unitG = Graphics.FromImage(unitBm))
                        {
                            unitG.CopyRenderSettingsFrom(g);
                            if (tile != null)
                            {
                                unitG.DrawImage(tile.Image, renderRect, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel);
                            }
                            if (unit.Type.HasTurret)
                            {
                                Point center = new Point(renderBounds.Width / 2, renderBounds.Height / 2);

                                void RenderTurret(Graphics ug, Tile turrTile, Point turrAdjust, Size tSize)
                                {
                                    Size turretSize = turrTile.Image.Size;
                                    Size turretRenderSize = new Size(turretSize.Width * tSize.Width / Globals.OriginalTileWidth, turretSize.Height * tSize.Height / Globals.OriginalTileHeight);
                                    Rectangle turrBounds = new Rectangle(center - new Size(turretRenderSize.Width / 2, turretRenderSize.Height / 2), turretRenderSize);
                                    turrBounds.Offset(
                                        turrAdjust.X * tSize.Width / Globals.PixelWidth,
                                        turrAdjust.Y * tSize.Height / Globals.PixelHeight
                                    );
                                    ug.DrawImage(turrTile.Image, turrBounds, 0, 0, turrTile.Image.Width, turrTile.Image.Height, GraphicsUnit.Pixel);
                                }

                                if (turretTile != null && turretTile.Image != null)
                                {
                                    RenderTurret(unitG, turretTile, turretAdjust, tileSize);
                                }
                                if (unit.Type.HasDoubleTurret && turret2Tile != null && turret2Tile.Image != null)
                                {
                                    RenderTurret(unitG, turret2Tile, turret2Adjust, tileSize);
                                }
                            }
                        }
                        g.DrawImage(unitBm, renderBounds, 0, 0, renderBounds.Width, renderBounds.Height, GraphicsUnit.Pixel, imageAttributes);
                    }
                }
            }
            Point centerPoint = GetVehicleRenderPoint();
            Point usedCenter = new Point(topLeft.X * Globals.PixelWidth + centerPoint.X, topLeft.Y * Globals.PixelHeight + centerPoint.Y);
            return new RenderInfo(usedCenter, render, unit);
        }

        public static (Rectangle, Action<Graphics>) RenderWaypoint(GameInfo gameInfo, bool soloMission, Size tileSize, ITeamColor[] flagColors, Waypoint waypoint,
            float alphaFactor, int offset, ShapeCacheManager cacheManager)
        {
            if (!waypoint.Point.HasValue)
            {
                return (Rectangle.Empty, (g) => { });
            }
            Point point = waypoint.Point.Value;
            bool isDefaultIcon = true;
            string tileGraphics = "trans.icn";
            int icon = 3;
            ITeamColor teamColor = null;
            double sizeMultiplier = 1;
            if (waypoint.IsPreview)
            {
                alphaFactor *= Globals.PreviewAlphaFloat;
            }
            alphaFactor = alphaFactor.Restrict(0, 1);
            int mpId = soloMission ? -1 : Waypoint.GetMpIdFromFlag(waypoint.Flag);
            Bitmap image = null;
            if (waypoint.Flag.HasFlag(WaypointFlag.CrateSpawn))
            {
                isDefaultIcon = false;
                tileGraphics = "scrate";
                icon = 0;
                sizeMultiplier = 2;
            }
            else if (mpId >= 0 && mpId < flagColors.Length)
            {
                isDefaultIcon = false;
                tileGraphics = "flagfly";
                icon = 0;
                teamColor = flagColors[mpId];
                // Always paint flags as opaque.
                //transparencyModifier = 1.0f;
            }
            string id = "waypoint_" + tileGraphics + "_icn" + icon + "_x" + sizeMultiplier + "_mpid" + mpId;
            image = cacheManager.GetImage(id);
            if (image == null)
            {
                bool gotTile = Globals.TheTilesetManager.GetTeamColorTileData(tileGraphics, icon, teamColor, out Tile tile);
                if (gotTile)
                {
                    image = new Bitmap(tile.Image);
                }
                else if (isDefaultIcon)
                {
                    using (Bitmap selectCursor = Globals.TheTilesetManager.GetTexture(@"DATA\ART\TEXTURES\SRGB\ICON_SELECT_FRIENDLY_X2_00.DDS", tileGraphics, icon, true))
                    {
                        Rectangle opaqueBounds = ImageUtils.CalculateOpaqueBounds(selectCursor);
                        image = selectCursor.FitToBoundingBox(opaqueBounds, Globals.OriginalTileHeight, Globals.OriginalTileHeight, Color.Transparent);
                    }
                }
                if (image != null)
                {
                    cacheManager.AddImage(id, image);
                }
            }
            if (image == null)
            {
                Debug.Print(string.Format("Waypoint graphics {0} ({1}) not found", tileGraphics, icon));
                return (Rectangle.Empty, (g) => { });
            }
            Point location = new Point(point.X * tileSize.Width, point.Y * tileSize.Height);
            Size renderSize = new Size(image.Width * tileSize.Width / Globals.OriginalTileWidth, image.Height * tileSize.Height / Globals.OriginalTileHeight);
            renderSize.Width = (int)Math.Round(renderSize.Width * sizeMultiplier);
            renderSize.Height = (int)Math.Round(renderSize.Height * sizeMultiplier);
            Rectangle renderBounds = new Rectangle(location, renderSize);
            Rectangle imgBounds = new Rectangle(Point.Empty, image.Size);
            bool isClipping = renderSize.Width > tileSize.Width || renderSize.Height > tileSize.Height;
            if (tileSize.Width > renderSize.Width)
            {
                // Pad. This rounds upwards because bottom and left are generally shadows.
                renderBounds.X += (int)Math.Round((tileSize.Width - renderSize.Width) / 2.0, MidpointRounding.AwayFromZero);
            }
            else if (tileSize.Width < renderSize.Width)
            {
                // Crop
                renderBounds.Width = tileSize.Width;
                imgBounds.Width = (int)Math.Round(tileSize.Width / sizeMultiplier);
                imgBounds.X = (image.Width - imgBounds.Width) / 2;
            }
            if (tileSize.Height > renderSize.Height)
            {
                // Pad. This rounds upwards because bottom and left are generally shadows.
                renderBounds.Y += (int)Math.Round((tileSize.Height - renderSize.Height) / 2.0, MidpointRounding.AwayFromZero);
            }
            else if (tileSize.Height < renderSize.Height)
            {
                // Crop
                renderBounds.Height = tileSize.Height;
                imgBounds.Height = (int)Math.Round(tileSize.Height / sizeMultiplier);
                imgBounds.Y = (image.Height - imgBounds.Height) / 2;
            }
            // Apply offset
            int actualOffsetX = offset * tileSize.Width / Globals.PixelWidth;
            int actualOffsetY = offset * tileSize.Height / Globals.PixelHeight;
            renderBounds.X += actualOffsetX;
            renderBounds.Y += actualOffsetY;
            renderBounds.Width = Math.Max(0, renderBounds.Width - actualOffsetX);
            renderBounds.Height = Math.Max(0, renderBounds.Height - actualOffsetY);
            void render(Graphics g)
            {
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, alphaFactor));
                    if (renderBounds.Width > 0 && renderBounds.Height > 0 && imgBounds.Width > 0 && imgBounds.Height > 0)
                    {
                        g.DrawImage(image, renderBounds, imgBounds.X, imgBounds.Y, imgBounds.Width, imgBounds.Height, GraphicsUnit.Pixel, imageAttributes);
                    }
                }
            }
            return (renderBounds, render);
        }

        private static Point GetVehicleRenderPoint()
        {
            return new Point(Globals.PixelWidth / 2, Globals.PixelHeight / 2);
        }

        private static Point GetInfantryRenderPoint(InfantryStoppingType ist)
        {
            return InfantryGroup.RenderPosition(ist, true);
        }

        private static Point GetTerrainRenderPoint(Terrain terrain)
        {
            return terrain.Type.CenterPoint;
        }

        private static Point GetBuildingRenderPoint(Building building)
        {
            return GeneralUtils.GetOccupiedCenter(building.Type.BaseOccupyMask, new Size(Globals.PixelWidth, Globals.PixelHeight));
        }

        public static void RenderAllBoundsFromCell<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(int, T)> renderList, CellMetrics metrics)
        {
            RenderAllBoundsFromCell(graphics, visibleCells, tileSize, renderList, metrics, Color.Green);
        }

        public static void RenderAllBoundsFromCell<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(int, T)> renderList, CellMetrics metrics, Color boundsColor)
        {
            RenderAllBoundsFromCell(graphics, visibleCells, tileSize, renderList.Select(tp => tp.Item1), metrics, boundsColor);
        }

        public static void RenderAllBoundsFromCell(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<int> renderList, CellMetrics metrics, Color boundsColor)
        {
            using (Pen boundsPen = new Pen(boundsColor, Math.Max(1, tileSize.Width / 16.0f)))
            {
                foreach (int cell in renderList)
                {
                    if (metrics.GetLocation(cell, out Point topLeft) && visibleCells.Contains(topLeft))
                    {
                        Rectangle bounds = new Rectangle(new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height), tileSize);
                        graphics.DrawRectangle(boundsPen, bounds);
                    }
                }
            }
        }

        public static void RenderAllBoundsFromPoint<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(Point, T)> renderList)
        {
            RenderAllBoundsFromPoint(graphics, visibleCells, tileSize, renderList.Select(tp => tp.Item1), Color.Green);
        }

        public static void RenderAllBoundsFromPoint(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<Point> renderList, Color boundsColor)
        {
            using (Pen boundsPen = new Pen(boundsColor, Math.Max(1, tileSize.Width / 16.0f)))
            {
                foreach (Point topLeft in renderList.Where(pt => visibleCells.Contains(pt)))
                {
                    Rectangle bounds = new Rectangle(new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height), tileSize);
                    graphics.DrawRectangle(boundsPen, bounds);
                }
            }
        }

        public static void RenderAllBoundsFromPoint<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(Point, T)> renderList, Color boundsColor)
        {
            using (Pen boundsPen = new Pen(boundsColor, Math.Max(1, tileSize.Width / 16.0f)))
            {
                foreach ((Point topLeft, T _) in renderList.Where(pt => visibleCells.Contains(pt.Item1)))
                {
                    Rectangle bounds = new Rectangle(new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height), tileSize);
                    graphics.DrawRectangle(boundsPen, bounds);
                }
            }
        }

        public static void RenderAllOccupierBoundsGreen<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(Point, T)> occupiers) where T : ICellOccupier, ICellOverlapper
        {
            RenderAllOccupierBounds(graphics, visibleCells, tileSize, occupiers, Color.Green, Color.Transparent);
        }

        public static void RenderAllOccupierCellsRed<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(Point, T)> occupiers) where T : ICellOccupier, ICellOverlapper
        {
            RenderAllOccupierBounds(graphics, visibleCells, tileSize, occupiers, Color.Transparent, Color.Red);
        }

        public static void RenderAllOccupierBounds<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(Point, T)> occupiers) where T : ICellOccupier, ICellOverlapper
        {
            RenderAllOccupierBounds(graphics, visibleCells, tileSize, occupiers, Color.Green, Color.Red);
        }

        public static void RenderAllOccupierBounds<T>(Graphics graphics, Rectangle visibleCells, Size tileSize, IEnumerable<(Point, T)> occupiers, Color boundsColor, Color occupierColor) where T : ICellOccupier, ICellOverlapper
        {
            float boundsPenSize = Math.Max(1, tileSize.Width / 16.0f);
            float occupyPenSize = Math.Max(0.5f, tileSize.Width / 32.0f);
            if (occupyPenSize == boundsPenSize)
            {
                boundsPenSize += 2;
            }
            if (boundsColor.A != 0)
            {
                using (Pen boundsPen = new Pen(boundsColor, boundsPenSize))
                {
                    foreach ((Point topLeft, T occupier) in occupiers)
                    {
                        Rectangle typeBounds = occupier.OverlapBounds;
                        Rectangle bounds = new Rectangle(
                            new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height),
                            new Size(typeBounds.Width * tileSize.Width, typeBounds.Height * tileSize.Height)
                        );
                        graphics.DrawRectangle(boundsPen, bounds);
                    }
                }
            }
            if (occupierColor.A != 0)
            {
                using (Pen occupyPen = new Pen(occupierColor, occupyPenSize))
                {
                    foreach ((Point topLeft, T occupier) in occupiers)
                    {
                        bool[,] occupyMask = occupier is Building bl ? bl.Type.BaseOccupyMask : occupier.OccupyMask;

                        for (int y = 0; y < occupyMask.GetLength(0); ++y)
                        {
                            for (int x = 0; x < occupyMask.GetLength(1); ++x)
                            {
                                if (!occupyMask[y, x])
                                {
                                    continue;
                                }
                                Rectangle occupyCellBounds = new Rectangle(new Point(topLeft.X + x, topLeft.Y + y), new Size(1, 1));
                                Rectangle occupyBounds = new Rectangle(
                                    new Point((topLeft.X + x) * tileSize.Width, (topLeft.Y + y) * tileSize.Height), tileSize);
                                if (visibleCells.Contains(occupyCellBounds))
                                {
                                    graphics.DrawRectangle(occupyPen, occupyBounds);
                                }
                            }
                        }
                    }
                }
            }
        }

        public static void RenderAllCrateOutlines(Graphics g, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, double tileScale, bool onlyIfBehindObjects)
        {
            RenderAllOverlayOutlines(g, gameInfo, map, visibleCells, tileSize, tileScale, OverlayTypeFlag.WoodCrate, onlyIfBehindObjects, Globals.OutlineColorCrateWood);
            RenderAllOverlayOutlines(g, gameInfo, map, visibleCells, tileSize, tileScale, OverlayTypeFlag.SteelCrate, onlyIfBehindObjects, Globals.OutlineColorCrateSteel);
        }
        
        public static void RenderAllSolidOverlayOutlines(Graphics g, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, double tileScale, bool onlyIfBehindObjects)
        {
            RenderAllOverlayOutlines(g, gameInfo, map, visibleCells, tileSize, tileScale, OverlayTypeFlag.Solid, onlyIfBehindObjects, Globals.OutlineColorSolidOverlay);
            RenderAllOverlayOutlines(g, gameInfo, map, visibleCells, tileSize, tileScale, OverlayTypeFlag.Wall, onlyIfBehindObjects, Globals.OutlineColorWall);
        }

        public static void RenderAllOverlayOutlines(Graphics g, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, double tileScale, OverlayTypeFlag types,
            bool onlyIfBehindObjects, Color outlineColor)
        {
            if (outlineColor.A == 0)
            {
                return;
            }
            Dictionary<Point, Overlay> includedPoints = new Dictionary<Point, Overlay>();
            List<int> includedCells = new List<int>();
            float outlineThickness = 0.05f;
            byte alphaThreshold = (byte)(Globals.UseClassicFiles ? 0x80 : 0x40);
            // Get all included points in an initial sweep so they're all available in the second processing step.
            foreach ((int cell, Overlay overlay) in map.Overlay)
            {
                OverlayType ovlt = overlay.Type;
                if (!ovlt.Flag.HasAnyFlags(types) || !map.Metrics.GetLocation(cell, out Point location)|| !visibleCells.Contains(location))
                {
                    continue;
                }
                if (onlyIfBehindObjects)
                {
                    if (overlay.Type.OpaqueMask == null) {
                        continue;
                    }
                    bool[] toCheck = overlay.Type.OpaqueMask[0, 0];
                    InfantryStoppingType[] toLoop = Enum.GetValues(typeof(InfantryStoppingType)).Cast<InfantryStoppingType>().ToArray();
                    bool occupied = false;
                    for (int i = 0; i < toLoop.Length; i++)
                    {
                        if (!toCheck[i])
                        {
                            continue;
                        }
                        InfantryStoppingType ist = toLoop[i];
                        if (IsOverlapped(map, location, true, ist, overlay, -1))
                        {
                            occupied = true;
                            break;
                        }
                    }
                    if (!occupied)
                    {
                        continue;
                    }
                }
                includedCells.Add(cell);
                includedPoints.Add(location, overlay);
            }
            // Now we have all cells to process, we can ensure the outlines for neighbouring wall cells are combined.
            foreach (int cell in includedCells)
            {
                if (!map.Overlay.Metrics.GetLocation(cell, out Point p) || !includedPoints.TryGetValue(p, out Overlay overlay))
                {
                    continue;
                }
                OverlayType ovlt = overlay.Type;
                Size cellSize = new Size(1, 1);
                Color outlineCol = Color.FromArgb(0xA0, outlineColor);
                Overlay tstOvl;
                // If this is a wall, exclude edge cells on sides that are the same type of wall, so they connect properly.
                bool includeAbove = !ovlt.IsWall || !includedPoints.TryGetValue(p.OffsetPoint(0, -1), out tstOvl) || tstOvl.Type.ID != ovlt.ID;
                bool includeRight = !ovlt.IsWall || !includedPoints.TryGetValue(p.OffsetPoint(1, 0), out tstOvl) || tstOvl.Type.ID != ovlt.ID;
                bool includeBelow = !ovlt.IsWall || !includedPoints.TryGetValue(p.OffsetPoint(0, 1), out tstOvl) || tstOvl.Type.ID != ovlt.ID;
                bool includeLefty = !ovlt.IsWall || !includedPoints.TryGetValue(p.OffsetPoint(-1, 0), out tstOvl) || tstOvl.Type.ID != ovlt.ID;
                int aroundMask = (includeAbove ? 1 : 0) | (includeRight ? 2 : 0) | (includeBelow ? 4 : 0) | (includeLefty ? 8 : 0);
                string ovlId = "outline_ovl_" + overlay.Type.Name + "_" + overlay.Icon + "_" + aroundMask + "_" + tileSize.Width + "x" + tileSize.Height;
                RegionData paintAreaRel = Globals.TheShapeCacheManager.GetShape(ovlId);
                if (paintAreaRel == null)
                {
                    using (Bitmap bm = new Bitmap(tileSize.Width * 3, tileSize.Height * 3, PixelFormat.Format32bppArgb))
                    {
                        using (Graphics ig = Graphics.FromImage(bm))
                        {
                            RenderOverlay(gameInfo, new Point(1, 1), null, tileSize, tileScale, overlay, true).Item2(ig);
                        }
                        paintAreaRel = ImageUtils.GetOutline(tileSize, bm, outlineThickness, alphaThreshold, Globals.UseClassicFiles);
                        // Wall connecting: if any side cells should be excluded so they connect to neighbouring cells,
                        // intersect the region with another region containing only the desired side cells.
                        if (ovlt.IsWall && aroundMask != (1 | 2 | 4 | 8))
                        {
                            using (Region outline = new Region(paintAreaRel))
                            {
                                using (Region rgn = new Region(new Rectangle(new Point(tileSize.Width, tileSize.Height), tileSize)))
                                {
                                    // Adds side cells that aren't cut off.
                                    if (includeAbove) rgn.Union(new Rectangle(new Point(tileSize.Width/**/, /**/              0), tileSize));
                                    if (includeRight) rgn.Union(new Rectangle(new Point(tileSize.Width * 2, tileSize.Height/**/), tileSize));
                                    if (includeBelow) rgn.Union(new Rectangle(new Point(tileSize.Width/**/, tileSize.Height * 2), tileSize));
                                    if (includeLefty) rgn.Union(new Rectangle(new Point(/**/             0, tileSize.Height/**/), tileSize));
                                    // Not sure if needed; adds corner cells as well if neighbouring cells are added.
                                    if (includeAbove && includeRight) rgn.Union(new Rectangle(new Point(tileSize.Width * 2, /**/              0), tileSize));
                                    if (includeRight && includeBelow) rgn.Union(new Rectangle(new Point(tileSize.Width * 2, tileSize.Height * 2), tileSize));
                                    if (includeBelow && includeLefty) rgn.Union(new Rectangle(new Point(/**/             0, tileSize.Height * 2), tileSize));
                                    if (includeLefty && includeAbove) rgn.Union(new Rectangle(new Point(/**/             0, /**/              0), tileSize));
                                    outline.Intersect(rgn);
                                    paintAreaRel = outline.GetRegionData();
                                }
                            }
                        }
                        Globals.TheShapeCacheManager.AddShape(ovlId, paintAreaRel);
                    }
                }
                int actualTopLeftX = tileSize.Width * (p.X -1);
                int actualTopLeftY = tileSize.Height * (p.Y -1);
                if (paintAreaRel != null)
                {
                    using (Region paintArea = new Region(paintAreaRel))
                    using (Brush brush = new SolidBrush(outlineCol))
                    {
                        paintArea.Translate(actualTopLeftX, actualTopLeftY);
                        g.FillRegion(brush, paintArea);
                    }
                }
            }
        }

        public static void RenderAllInfantryOutlines(Graphics g, Map map, Rectangle visibleCells, Size tileSize, bool onlyIfBehindObjects)
        {
            float outlineThickness = 0.05f;
            byte alphaThreshold = (byte)(Globals.UseClassicFiles ? 0x80 : 0x40);
            //double lumThreshold = 0.01d;
            visibleCells.Inflate(1, 1);
            foreach (var (location, infantryGroup) in map.Technos.OfType<InfantryGroup>().OrderBy(i => map.Metrics.GetCell(i.Location)))
            {
                Size cellSize = new Size(1, 1);
                if (!visibleCells.Contains(location))
                {
                    continue;
                }
                InfantryStoppingType[] toCheck = Enum.GetValues(typeof(InfantryStoppingType)).Cast<InfantryStoppingType>().ToArray();
                foreach (InfantryStoppingType ist in toCheck)
                {
                    Infantry infantry = infantryGroup.Infantry[(int)ist];
                    if (infantry == null)
                    {
                        continue;
                    }
                    if (onlyIfBehindObjects)
                    {
                        if (!IsOverlapped(map, location, false, ist, infantryGroup, infantry.DrawOrderCache))
                        {
                            continue;
                        }
                    }
                    Color outlineCol = Color.FromArgb(0x80, Globals.TheTeamColorManager.GetBaseColor(infantry.House?.UnitTeamColor));
                    string infId = "outline_inf_" + infantry.Type.Name + '_' + ((int)ist) + '_' + infantry.Direction.ID + "_" + tileSize.Width + "x" + tileSize.Height;
                    RegionData paintAreaRel = Globals.TheShapeCacheManager.GetShape(infId);
                    if (paintAreaRel == null)
                    {
                        using (Bitmap bm = new Bitmap(tileSize.Width * 3, tileSize.Height * 3, PixelFormat.Format32bppArgb))
                        {
                            using (Graphics ig = Graphics.FromImage(bm))
                            {
                                RenderInfantry(new Point(1, 1), tileSize, infantry, ist, true).RenderAction(ig);
                            }
                            paintAreaRel = ImageUtils.GetOutline(tileSize, bm, outlineThickness, alphaThreshold, Globals.UseClassicFiles);
                            Globals.TheShapeCacheManager.AddShape(infId, paintAreaRel);
                        }
                    }
                    // Rendered in a 3x3 cell frame, so subtract one.
                    int actualTopLeftX = (location.X - 1) * tileSize.Width;
                    int actualTopLeftY = (location.Y - 1) * tileSize.Height;
                    if (paintAreaRel != null)
                    {
                        using (Region paintArea = new Region(paintAreaRel))
                        using (Brush brush = new SolidBrush(outlineCol))
                        {
                            paintArea.Translate(actualTopLeftX, actualTopLeftY);
                            g.FillRegion(brush, paintArea);
                        }
                    }
                }
            }
        }

        public static void RenderAllUnitOutlines(Graphics g, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, bool onlyIfBehindObjects)
        {
            RenderAllObjectOutlines(g, gameInfo, map, map.Technos.OfType<Unit>(), visibleCells, tileSize, true,
                (h) => h.UnitTeamColor, (gr, p, unt) => RenderUnit(gameInfo, new Point(1, 1), tileSize, unt, true).RenderAction(gr), Color.Black);
        }

        public static void RenderAllBuildingOutlines(Graphics g, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, double tileScale, bool onlyIfBehindObjects)
        {
            RenderAllObjectOutlines(g, gameInfo, map, map.Buildings.OfType<Building>(), visibleCells, tileSize, true,
                (h) => h.BuildingTeamColor, (gr, p, bld) => RenderBuilding(gameInfo, null, p, tileSize, tileScale, bld, true).RenderAction(gr), Color.Black);
        }

        public static void RenderAllTerrainOutlines(Graphics g, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, double tileScale, bool onlyIfBehindObjects)
        {
            RenderAllObjectOutlines(g, gameInfo, map, map.Technos.OfType<Terrain>(), visibleCells, tileSize, true,
                null, (gr, p, trn) => RenderTerrain(p, tileSize, tileScale, trn, true).RenderAction(gr), Globals.OutlineColorTerrain);
        }

        /// <summary>
        /// Unified function for rendering outlines for techno objects. Infantry are still separate, because of the whole InfantryGroup mess.
        /// </summary>
        /// <typeparam name="T">Techno that's being handled.</typeparam>
        /// <param name="g">Graphics object to paint on.</param>
        /// <param name="gameInfo">GameInfo object for this game.</param>
        /// <param name="map">Map, to check metrics and object overlaps.</param>
        /// <param name="occupiers">The list of occupiers to render outlines for.</param>
        /// <param name="visibleCells">Visible area on the screen in which these outlines should be rendered.</param>
        /// <param name="tileSize">Size of the map tiles.</param>
        /// <param name="onlyIfBehindObjects">True to only render objects that are overlapped by something.</param>
        /// <param name="colorPick">Function to get the preferred team color name from a House.</param>
        /// <param name="RenderAction">Action to render an object of the handled type at a specific point on a graphics object.</param>
        /// <param name="fallbackColor">Fallback colour in case no House or <paramref name="colorPick"/> function are available.</param>
        private static void RenderAllObjectOutlines<T>(Graphics g, GameInfo gameInfo, Map map, IEnumerable<(Point Location, T Occupier)> occupiers,
            Rectangle visibleCells, Size tileSize, bool onlyIfBehindObjects, Func<HouseType, string> colorPick, Action<Graphics, Point, T> RenderAction, Color fallbackColor)
            where T: ITechno, ICellOverlapper, ICellOccupier, ICloneable
        {
            float outlineThickness = 0.05f;
            byte alphaThreshold = (byte)(Globals.UseClassicFiles ? 0x80 : 0x40);
            //double lumThreshold = 0.01d;
            visibleCells.Inflate(1, 1);
            foreach ((Point objLocation, T placedObj) in occupiers.OrderBy(i => map.Metrics.GetCell(i.Location)))
            {
                // This is a visibility check; check cells that are deemed "visible".
                bool[,][] opaqueMask = placedObj.OpaqueMask;
                bool[,] occupyMask = placedObj.OccupyMask;
                int paintOrder = placedObj.DrawOrderCache;
                int maskY = opaqueMask == null ? 0 : opaqueMask.GetLength(0);
                int maskX = opaqueMask == null ? 0 : opaqueMask.GetLength(1);
                // If not in currently viewed area, ignore.
                Rectangle objBounds = new Rectangle(objLocation, placedObj.OccupyMask.GetDimensions());
                if (!visibleCells.IntersectsWith(objBounds))
                {
                    continue;
                }
                if (onlyIfBehindObjects)
                {
                    // Select actual map points for all visible points in opaqueMask
                    bool allOpaque = true;
                    // only evaluate center point
                    Point[] opaquePoints = Enumerable.Range(0, maskY).SelectMany(nrY => Enumerable.Range(0, maskX).Select(nrX => new Point(nrX, nrY)))
                        .Where(pt => opaqueMask[pt.Y, pt.X] != null && opaqueMask[pt.Y, pt.X].Length > 0 && opaqueMask[pt.Y, pt.X].Any()).ToArray();
                    foreach (Point opaquePoint in opaquePoints)
                    {
                        Point realPoint = new Point(objLocation.X + opaquePoint.X, objLocation.Y + opaquePoint.Y);
                        InfantryStoppingType[] toCheck = Enum.GetValues(typeof(InfantryStoppingType)).Cast<InfantryStoppingType>().ToArray();
                        bool isSubOverlapped = false;
                        bool[] opaqueCellMask = opaqueMask[opaquePoint.Y, opaquePoint.X];
                        foreach (InfantryStoppingType ist in toCheck)
                        {
                            if (!opaqueCellMask[(int)ist])
                            {
                                continue;
                            }
                            if (IsOverlapped(map, realPoint, false, ist, placedObj, paintOrder))
                            {
                                isSubOverlapped = true;
                                break;
                            }
                        }
                        // if any of the occupied sub-cells are overlapped, consider it partially overlapped and thus eligible for outline.
                        if (!isSubOverlapped)
                        {
                            allOpaque = false;
                            break;
                        }
                    }
                    if (!allOpaque)
                    {
                        continue;
                    }
                }
                Size cellSize = new Size(maskX + 2, maskY + 2);
                Color houseCol = fallbackColor;
                if (placedObj.House != null && colorPick != null)
                {
                    houseCol = Color.FromArgb(0x80, Globals.TheTeamColorManager.GetBaseColor(colorPick(placedObj.House)));
                }
                string id = "outline_" + typeof(T).Name + "_" + placedObj.TechnoType.Name + "_fr" + placedObj.DrawFrameCache + "_" + tileSize.Width + "x" + tileSize.Height;
                RegionData paintAreaRel = Globals.TheShapeCacheManager.GetShape(id);
                if (paintAreaRel == null)
                {
                    // Clone without preview flag.
                    T toRender = placedObj;
                    if (placedObj.IsPreview)
                    {
                        toRender = (T)placedObj.Clone();
                        placedObj.IsPreview = false;
                        if (placedObj is Building bld)
                        {
                            bld.BasePriority = 0;
                            bld.IsPrebuilt = true;
                        }
                    }
                    using (Bitmap bm = new Bitmap(tileSize.Width * cellSize.Width, tileSize.Height * cellSize.Width, PixelFormat.Format32bppArgb))
                    {
                        using (Graphics ig = Graphics.FromImage(bm))
                        {
                            RenderAction(ig, new Point(1, 1), toRender);
                        }
                        paintAreaRel = ImageUtils.GetOutline(tileSize, bm, outlineThickness, alphaThreshold, Globals.UseClassicFiles);
                        Globals.TheShapeCacheManager.AddShape(id, paintAreaRel);
                    }
                }
                int paintPosTopLeftX = (objLocation.X - 1) * tileSize.Width;
                int paintPosTopLeftY = (objLocation.Y - 1) * tileSize.Height;
                if (paintAreaRel != null)
                {
                    using (Region paintArea = new Region(paintAreaRel))
                    using (Brush brush = new SolidBrush(houseCol))
                    {
                        paintArea.Translate(paintPosTopLeftX, paintPosTopLeftY);
                        g.FillRegion(brush, paintArea);
                    }
                }
            }
        }

        /// <summary>
        /// Check if an object is considered overlapped by something on the map.
        /// </summary>
        /// <param name="map">Map to check on.</param>
        /// <param name="location">Location to check for overlap.</param>
        /// <param name="unitsAlwaysOverlap">True to immediately return true if the cell is occupied by units.</param>
        /// <param name="ist">When filled in, the overlapper is treated as infantry on that location.</param>
        /// <param name="objectToCheck">Object for which overlap is being checked. This object is automatically ignored in the objects it loops over to check for overlaps.</param>
        /// <param name="objectPaintOrder">Cached paint order of the object, to easily check if it can be overlapped at all.</param>
        /// <returns>true if the cell is considered filled enough to overlap things.</returns>
        private static bool IsOverlapped(Map map, Point location, bool unitsAlwaysOverlap, InfantryStoppingType? ist, ICellOverlapper objectToCheck, int objectPaintOrder)
        {
            ICellOccupier techno = map.Technos[location];
            int subIndex = ist.HasValue ? (int)ist.Value : 0;
            // Single-cell occupier. Always pass. Since this is only used for single-cell objects, only map.Technos needs to be checked.
            if (unitsAlwaysOverlap && (techno is Unit || techno is InfantryGroup) && techno != objectToCheck)
            {
                if (!(techno is InfantryGroup ig) || ig.Infantry[subIndex] != null)
                {
                    return true;
                }
            }
            // Logic for multi-cell occupiers; buildings and terrain.
            // Return true if either an occupied cell, or overlayed by graphics deemed opaque.
            ICellOverlapper[] technos = map.Overlappers.OverlappersAt(location).Where(ov => !ReferenceEquals(ov,objectToCheck)).ToArray();
            if (technos.Length == 0)
            {
                return false;
            }
            // Overlappers list contains both buildings and other technos.
            foreach (ICellOverlapper ovl in technos)
            {
                ICellOccupier occ = ovl as ICellOccupier;
                if (occ == null)
                {
                    continue;
                }
                bool[,][] opaqueMask = ovl.OpaqueMask;
                int maskY = opaqueMask == null ? 0 : opaqueMask.GetLength(0);
                int maskX = opaqueMask == null ? 0 : opaqueMask.GetLength(1);
                Point? pt = map.Technos[occ] ?? map.Buildings[occ];
                if (!pt.HasValue)
                {
                    continue;
                }
                // Object we're comparing with was drawn before the current one, so it can't possible overlap it.
                // This caching allows extremely easy checks on overlap without much processing.
                if (ovl is ITechno paintedObj && paintedObj.DrawOrderCache < objectPaintOrder)
                {
                    continue;
                }
                if (ovl is InfantryGroup ig && (ig.Infantry[subIndex] == null || ig.Infantry[subIndex].DrawOrderCache < objectPaintOrder))
                {
                    continue;
                }
                // Get list of points, find current point in the list.
                Rectangle boundsRect = new Rectangle(pt.Value, new Size(maskX, maskY));
                List<Point> pts = boundsRect.Points().OrderBy(p => p.Y * map.Metrics.Width + p.X).ToList();
                int index = pts.IndexOf(location);
                if (index == -1)
                {
                    continue;
                }
                // Trick to convert 2-dimensional arrays to linear format.
                bool[][] opaqueArr = opaqueMask.Cast<bool[]>().ToArray();
                if (index < opaqueArr.Length && opaqueArr[index] != null && subIndex < opaqueArr[index].Length && opaqueArr[index][subIndex])
                {
                    // If obscured from view by graphics, return true.
                    return true;
                }
            }
            return false;
        }

        public static void RenderAllFootballAreas(Graphics graphics, Map map, Rectangle visibleCells, Size tileSize, double tileScale, GameInfo gameInfo)
        {
            if (!gameInfo.SupportsMapLayer(MapLayerFlag.FootballArea))
            {
                return;
            }
            HashSet<Point> footballPoints = new HashSet<Point>();
            Rectangle renderArea = map.Metrics.Bounds;
            renderArea.Intersect(visibleCells);
            foreach (Waypoint waypoint in map.Waypoints)
            {
                if (!waypoint.Point.HasValue || Waypoint.GetMpIdFromFlag(waypoint.Flag) == -1)
                {
                    continue;
                }
                Point[] roadPoints = new Rectangle(waypoint.Point.Value.X - 1, waypoint.Point.Value.Y - 1, 4, 3).Points().ToArray();
                foreach (Point p in roadPoints.Where(p => renderArea.Contains(p)))
                {
                    footballPoints.Add(p);
                }
            }
            foreach (Point p in footballPoints.OrderBy(p => p.Y * map.Metrics.Width + p.X))
            {
                Overlay footballTerrain = new Overlay()
                {
                    Type = SoleSurvivor.OverlayTypes.Road,
                    IsPreview = true,
                };
                RenderOverlay(gameInfo, p, null, tileSize, tileScale, footballTerrain, false).Item2(graphics);
            }
        }

        public static void RenderWaypointFlags(Graphics graphics, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, ShapeCacheManager cacheManager)
        {
            // Re-render flags on top of football areas.
            List<Waypoint> flagWayPoints = new List<Waypoint>();
            Dictionary<int, int> flagOverlapMpCheck = new Dictionary<int, int>();
            Dictionary<Waypoint, int> flagOffsets = new Dictionary<Waypoint, int>();
            // Get all waypoints. Ignore the preview if it is on the same cell as the same actual waypoint.
            // Preview waypoint is always only one, and added at the end, so a sequential run always works.
            foreach (Waypoint waypoint in map.Waypoints)
            {
                int mpId = Waypoint.GetMpIdFromFlag(waypoint.Flag);
                if (waypoint.Point.HasValue && mpId >= 0 && visibleCells.Contains(waypoint.Point.Value)
                    && map.Metrics.GetCell(waypoint.Point.Value, out int cell))
                {
                    bool alreadyExists = flagOverlapMpCheck.TryGetValue(mpId, out int mpCell) && cell == mpCell;
                    if (!alreadyExists)
                    {
                        flagWayPoints.Add(waypoint);
                        flagOverlapMpCheck[mpId] = cell;
                    }
                }
            }
            // Create offsets if multiple flags are on the same cell.
            flagWayPoints = flagWayPoints.OrderBy(w => Waypoint.GetMpIdFromFlag(w.Flag)).ToList();
            Dictionary<int, int> flagOverlapPoints = new Dictionary<int, int>();
            foreach (Waypoint waypoint in flagWayPoints)
            {
                if (map.Metrics.GetCell(waypoint.Point.Value, out int cell))
                {
                    if (!flagOverlapPoints.TryGetValue(cell, out int amount))
                    {
                        flagOverlapPoints.Add(cell, 1);
                    }
                    else
                    {
                        flagOverlapPoints[cell] = amount + 1;
                    }
                    flagOffsets[waypoint] = amount * 2;
                }
            }
            // Paint the flags.
            ITeamColor[] flagColors = map.FlagColors;
            foreach (Waypoint wp in flagWayPoints)
            {
                flagOffsets.TryGetValue(wp, out int offset);
                RenderWaypoint(gameInfo, false, tileSize, flagColors, wp, wp.IsPreview ? Globals.PreviewAlphaFloat : 1.0f, offset, cacheManager).Item2(graphics);
            }
        }

        public static void RenderAllFakeBuildingLabels(Graphics graphics, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize)
        {
            RenderAllFakeBuildingLabels(graphics, gameInfo, map.Buildings.OfType<Building>(), visibleCells, tileSize);
        }

        public static void RenderAllFakeBuildingLabels(Graphics graphics, GameInfo gameInfo, IEnumerable<(Point topLeft, Building building)> buildings, Rectangle visibleCells, Size tileSize)
        {
            Color textColor = Color.White;
            Color backPaintColor = Color.Black;
            StringFormat stringFormat = new StringFormat
            {
                Alignment = StringAlignment.Center,
                LineAlignment = StringAlignment.Center
            };
            string classicFont = null;
            bool cropClassicFont = false;
            TeamRemap remapClassicFont = null;
            if (Globals.TheTilesetManager is TilesetManagerClassic tsmc && Globals.TheTeamColorManager is TeamRemapManager trm)
            {
                classicFont = gameInfo.GetClassicFontInfo(ClassicFont.CellTriggers, tsmc, trm, textColor, out cropClassicFont, out remapClassicFont);
            }
            string fakeText = Globals.TheGameTextManager["TEXT_UI_FAKE"];
            double tileScaleHor = tileSize.Width / 128.0;

            using (SolidBrush fakeBackgroundBrushPrev = new SolidBrush(Color.FromArgb(128 * 2 / 3, backPaintColor)))
            using (SolidBrush fakeBackgroundBrush = new SolidBrush(Color.FromArgb(256 * 2 / 3, backPaintColor)))
            using (ImageAttributes imageAttributes = new ImageAttributes())
            {
                foreach ((Point topLeft, Building building) in buildings)
                {
                    if (!building.Type.IsFake)
                    {
                        continue;
                    }
                    Rectangle buildingCellBounds = new Rectangle(topLeft, building.Type.Size);
                    if (!visibleCells.IntersectsWith(buildingCellBounds))
                    {
                        continue;
                    }
                    bool forPreview = building.IsPreview;
                    Size maxSize = building.Type.Size;
                    Rectangle buildingBounds = new Rectangle(
                        new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height),
                        new Size(maxSize.Width * tileSize.Width, maxSize.Height * tileSize.Height)
                    );
                    if (classicFont == null)
                    {
                        using (SolidBrush fakeTextBrush = new SolidBrush(Color.FromArgb(forPreview ? Globals.PreviewAlphaInt : 255, textColor)))
                        {
                            using (Font font = graphics.GetAdjustedFont(fakeText, SystemFonts.DefaultFont, buildingBounds.Width, buildingBounds.Height,
                                Math.Max(1, (int)Math.Round(12 * tileScaleHor)), Math.Max(1, (int)Math.Round(24 * tileScaleHor)), stringFormat, true))
                            {
                                SizeF textBounds = graphics.MeasureString(fakeText, font, buildingBounds.Width, stringFormat);
                                RectangleF backgroundBounds = new RectangleF(buildingBounds.Location, textBounds);
                                graphics.FillRectangle(forPreview ? fakeBackgroundBrushPrev : fakeBackgroundBrush, backgroundBounds);
                                graphics.DrawString(fakeText, font, fakeTextBrush, backgroundBounds, stringFormat);
                            }
                        }
                    }
                    else
                    {
                        Rectangle buildingRenderBounds = new Rectangle(
                            new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height),
                            new Size(maxSize.Width * tileSize.Width, maxSize.Height * tileSize.Height)
                        );
                        string fkId = "fake_classic_" + maxSize.Width + "x" + maxSize.Height;
                        Bitmap fkBm = Globals.TheShapeCacheManager.GetImage(fkId);
                        if (fkBm == null)
                        {
                            Rectangle buildingBoundsClassic = new Rectangle(Point.Empty, new Size(maxSize.Width * Globals.OriginalTileWidth, maxSize.Height * Globals.OriginalTileHeight));
                            fkBm = new Bitmap(buildingBoundsClassic.Width, buildingBoundsClassic.Height);
                            using (Graphics bmgr = Graphics.FromImage(fkBm))
                            {
                                int[] indices = Encoding.ASCII.GetBytes(fakeText).Select(x => (int)x).ToArray();
                                using (Bitmap txt = RenderTextFromSprite(classicFont, remapClassicFont, Size.Empty, indices, false, cropClassicFont))
                                {
                                    int frameWidth = Math.Min(txt.Width + 2, buildingBoundsClassic.Width);
                                    int frameHeight = Math.Min(txt.Height + 2, buildingBoundsClassic.Height);
                                    Rectangle backgroundBounds = new Rectangle(Point.Empty, new Size(frameWidth, frameHeight));
                                    Rectangle frameRect = new Rectangle(0, 0, frameWidth, frameHeight);
                                    Rectangle textRect = new Rectangle(1, 1, txt.Width, txt.Height);
                                    bmgr.FillRectangle(fakeBackgroundBrush, frameRect);
                                    bmgr.DrawImage(txt, textRect, 0, 0, txt.Width, txt.Height, GraphicsUnit.Pixel);
                                }
                            }
                            Globals.TheShapeCacheManager.AddImage(fkId, fkBm);
                        }
                        imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, building.IsPreview ? 0.5f : 1.0f));
                        graphics.DrawImage(fkBm, buildingRenderBounds, 0, 0, fkBm.Width, fkBm.Height, GraphicsUnit.Pixel, imageAttributes);
                        
                    }
                }
            }
        }

        public static void RenderAllRebuildPriorityLabels(Graphics graphics, GameInfo gameInfo, IEnumerable<(Point topLeft, Building building)> buildings, Rectangle visibleCells, Size tileSize, double tilescale)
        {
            Color textColor = Color.Red;
            Color backPaintColor = Color.Black;
            StringFormat stringFormat = new StringFormat
            {
                Alignment = StringAlignment.Center,
                LineAlignment = StringAlignment.Center
            };
            string classicFont = null;
            bool cropClassicFont = false;
            TeamRemap remapClassicFont = null;
            if (Globals.TheTilesetManager is TilesetManagerClassic tsmc && Globals.TheTeamColorManager is TeamRemapManager trm)
            {
                classicFont = gameInfo.GetClassicFontInfo(ClassicFont.CellTriggers, tsmc, trm, textColor, out cropClassicFont, out remapClassicFont);
            }
            foreach ((Point topLeft, Building building) in buildings)
            {
                if (building.BasePriority < 0 || !visibleCells.IntersectsWith(new Rectangle(topLeft, building.Type.Size)))
                {
                    continue;
                }
                Size maxSize = building.Type.Size;
                Rectangle buildingRenderBounds = new Rectangle(
                    new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height),
                    new Size(maxSize.Width * tileSize.Width, maxSize.Height * tileSize.Height)
                );
                double tileScaleHor = tileSize.Width / 128.0;
                string priText = building.BasePriority.ToString();
                using (SolidBrush baseBackgroundBrush = new SolidBrush(Color.FromArgb(256 * 2 / 3, backPaintColor)))
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, building.IsPreview ? 0.5f : 1.0f));
                    if (classicFont == null)
                    {
                        using (SolidBrush baseTextBrush = new SolidBrush(Color.FromArgb(255, textColor)))
                        using (Font font = graphics.GetAdjustedFont(priText, SystemFonts.DefaultFont, buildingRenderBounds.Width, buildingRenderBounds.Height,
                            Math.Max(1, (int)Math.Round(12 * tileScaleHor)), Math.Max(1, (int)Math.Round(24 * tileScaleHor)), stringFormat, true))
                        {
                            SizeF textBounds = graphics.MeasureString(priText, font, buildingRenderBounds.Width, stringFormat);
                            RectangleF backgroundBounds = new RectangleF(new PointF(buildingRenderBounds.X, buildingRenderBounds.Y), textBounds);
                            backgroundBounds.Offset((buildingRenderBounds.Width - textBounds.Width) / 2.0f, buildingRenderBounds.Height - textBounds.Height);
                            graphics.FillRectangle(baseBackgroundBrush, backgroundBounds);
                            graphics.DrawString(priText, font, baseTextBrush, backgroundBounds, stringFormat);
                        }
                    }
                    else
                    {
                        string priId = "priority_classic_" + maxSize.Width + "x" + maxSize.Height + "_" + priText;
                        Bitmap priBm = Globals.TheShapeCacheManager.GetImage(priId);
                        if (priBm == null)
                        {
                            Rectangle buildingBounds = new Rectangle(Point.Empty, new Size(maxSize.Width * Globals.OriginalTileWidth, maxSize.Height * Globals.OriginalTileHeight));
                            priBm = new Bitmap(buildingBounds.Width, buildingBounds.Height);
                            using (Graphics bmgr = Graphics.FromImage(priBm))
                            {
                                int[] indices = Encoding.ASCII.GetBytes(priText).Select(x => (int)x).ToArray();
                                using (Bitmap txt = RenderTextFromSprite(classicFont, remapClassicFont, Size.Empty, indices, false, cropClassicFont))
                                {
                                    int textOffsetX = (buildingBounds.Width - txt.Width) / 2;
                                    int textOffsetY = (buildingBounds.Height - txt.Height - 1);
                                    int frameOffsetX = Math.Max(textOffsetX, -tileSize.Width) - 1;
                                    int frameOffsetY = Math.Max(textOffsetY, -tileSize.Height) - 1;
                                    int frameWidth = Math.Min(txt.Width + 2, buildingBounds.Width);
                                    int frameHeight = Math.Min(txt.Height + 2, buildingBounds.Height);
                                    Rectangle frameRect = new Rectangle(frameOffsetX, frameOffsetY, frameWidth, frameHeight);
                                    Rectangle textRect = new Rectangle(textOffsetX, textOffsetY, txt.Width, txt.Height);
                                    bmgr.FillRectangle(baseBackgroundBrush, frameRect);
                                    bmgr.DrawImage(txt, textRect, 0, 0, txt.Width, txt.Height, GraphicsUnit.Pixel);
                                }
                            }
                            Globals.TheShapeCacheManager.AddImage(priId, priBm);
                        }
                        imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, building.IsPreview ? 0.5f : 1.0f));
                        graphics.DrawImage(priBm, buildingRenderBounds, 0, 0, priBm.Width, priBm.Height, GraphicsUnit.Pixel, imageAttributes);
                        
                    }
                }
            }
        }

        public static void RenderAllTechnoTriggers(Graphics graphics, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, MapLayerFlag layersToRender)
        {
            RenderAllTechnoTriggers(graphics, gameInfo, map.Technos, map.Buildings, visibleCells, tileSize, layersToRender, Color.LimeGreen, null, false);
        }

        public static void RenderAllTechnoTriggers(Graphics graphics, GameInfo gameInfo, OccupierSet<ICellOccupier> mapTechnos, OccupierSet<ICellOccupier> mapBuildings, Rectangle visibleCells, Size tileSize, MapLayerFlag layersToRender, Color color, string toPick, bool excludePick)
        {
            string classicFontLarge = null;
            bool cropClassicFontLarge = false;
            string classicFontSmall = null;
            bool cropClassicFontSmall = false;
            TeamRemap remapClassicFontLarge = null;
            TeamRemap remapClassicFontSmall = null;
            if (Globals.TheTilesetManager is TilesetManagerClassic tsmc && Globals.TheTeamColorManager is TeamRemapManager trm)
            {
                classicFontLarge = gameInfo.GetClassicFontInfo(ClassicFont.TechnoTriggers, tsmc, trm, color, out cropClassicFontLarge, out remapClassicFontLarge);
                classicFontSmall = gameInfo.GetClassicFontInfo(ClassicFont.TechnoTriggersSmall, tsmc, trm, color, out cropClassicFontSmall, out remapClassicFontSmall);
            }
            double tileScaleHor = tileSize.Width / 128.0;
            float borderSize = Math.Max(0.5f, tileSize.Width / 60.0f);
            // The "bounds" in this are a bit weird; they have the real paint position, but the size is relative to Globals.OriginalTileSize
            List<(string trigger, Rectangle bounds, int alpha)> allTriggers = new List<(string trigger, Rectangle bounds, int alpha)>();
            if (mapTechnos != null)
            {
                foreach ((Point topLeft, ICellOccupier techno) in mapTechnos)
                {
                    Point location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
                    (string trigger, Rectangle bounds, int alpha)[] triggers = null;
                    if (techno is Terrain terrain && !Trigger.IsEmpty(terrain.Trigger))
                    {
                        if (layersToRender.HasFlag(MapLayerFlag.Terrain))
                        {
                            if (visibleCells.IntersectsWith(new Rectangle(topLeft, terrain.Type.Size)))
                            {
                                Size size = new Size(terrain.Type.Size.Width * Globals.OriginalTileWidth, terrain.Type.Size.Height * Globals.OriginalTileHeight);
                                triggers = new (string, Rectangle, int)[] { (terrain.Trigger, new Rectangle(location, size),
                                    terrain.IsPreview ? Globals.PreviewAlphaInt : 256) };
                            }
                        }
                    }
                    else if (techno is Unit unit && !Trigger.IsEmpty(unit.Trigger))
                    {
                        if (layersToRender.HasFlag(MapLayerFlag.Units))
                        {
                            if (visibleCells.Contains(topLeft))
                            {
                                triggers = new (string, Rectangle, int)[] { (unit.Trigger, new Rectangle(location, Globals.OriginalTileSize),
                                    unit.IsPreview ? Globals.PreviewAlphaInt : 256) };
                            }
                        }
                    }
                    else if (techno is InfantryGroup infantryGroup)
                    {
                        if (layersToRender.HasFlag(MapLayerFlag.Infantry))
                        {
                            if (!visibleCells.Contains(topLeft))
                            {
                                continue;
                            }
                            Size size = tileSize;
                            Size boundSize = Globals.OriginalTileSize;
                            List<(string, Rectangle, int)> infantryTriggers = new List<(string, Rectangle, int)>();
                            for (int i = 0; i < infantryGroup.Infantry.Length; ++i)
                            {
                                Infantry infantry = infantryGroup.Infantry[i];
                                if (infantry == null || Trigger.IsEmpty(infantry.Trigger))
                                {
                                    continue;
                                }
                                Size offset = Size.Empty;
                                switch ((InfantryStoppingType)i)
                                {
                                    case InfantryStoppingType.UpperLeft:
                                        offset.Width = -size.Width / 4;
                                        offset.Height = -size.Height / 4;
                                        break;
                                    case InfantryStoppingType.UpperRight:
                                        offset.Width = size.Width / 4;
                                        offset.Height = -size.Height / 4;
                                        break;
                                    case InfantryStoppingType.LowerLeft:
                                        offset.Width = -size.Width / 4;
                                        offset.Height = size.Height / 4;
                                        break;
                                    case InfantryStoppingType.LowerRight:
                                        offset.Width = size.Width / 4;
                                        offset.Height = size.Height / 4;
                                        break;
                                }
                                Rectangle bounds = new Rectangle(location + offset, boundSize);
                                infantryTriggers.Add((infantry.Trigger, bounds, infantry.IsPreview ? Globals.PreviewAlphaInt : 256));
                            }
                            triggers = infantryTriggers.ToArray();
                        }
                    }
                    if (triggers != null)
                    {
                        allTriggers.AddRange(triggers);
                    }
                }
            }
            if (mapBuildings != null)
            {
                foreach ((Point topLeft, ICellOccupier techno) in mapBuildings)
                {
                    Point location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
                    if (techno is Building building && !Trigger.IsEmpty(building.Trigger))
                    {
                        if (layersToRender.HasFlag(MapLayerFlag.Buildings))
                        {
                            if (visibleCells.IntersectsWith(new Rectangle(topLeft, building.Type.Size)))
                            {
                                Size size = new Size(building.Type.Size.Width * Globals.OriginalTileWidth, building.Type.Size.Height * Globals.OriginalTileHeight);
                                allTriggers.Add((building.Trigger, new Rectangle(location, size),
                                    building.IsPreview ? Globals.PreviewAlphaInt : 256));
                            }
                        }
                    }
                }
            }
            StringFormat stringFormat = new StringFormat
            {
                Alignment = StringAlignment.Center,
                LineAlignment = StringAlignment.Center
            };
            foreach ((string trigger, Rectangle bounds, int alpha) in allTriggers.Where(x => toPick == null
            || (excludePick && !x.trigger.Equals(toPick, StringComparison.OrdinalIgnoreCase))
                || (!excludePick && x.trigger.Equals(toPick, StringComparison.OrdinalIgnoreCase))))
            {
                // Larger than a single cell.
                bool isLarge = bounds.Width > Globals.OriginalTileWidth;
                string classicFont = isLarge ? classicFontLarge : classicFontSmall;
                bool cropClassicFont = isLarge ? cropClassicFontLarge : cropClassicFontSmall;
                TeamRemap remapClassicFont = isLarge ? remapClassicFontLarge : remapClassicFontSmall;
                Color alphaColor = Color.FromArgb(alpha.Restrict(0,255), color);
                if (classicFont == null)
                {
                    int width = bounds.Width * tileSize.Width / Globals.OriginalTileWidth;
                    int height = bounds.Height * tileSize.Height / Globals.OriginalTileHeight;
                    Rectangle realBounds = new Rectangle(bounds.Location, new Size(width, height));
                    using (SolidBrush technoTriggerBackgroundBrush = new SolidBrush(Color.FromArgb((96 * alpha / 256).Restrict(0, 255), Color.Black)))
                    using (SolidBrush technoTriggerBrush = new SolidBrush(alphaColor))
                    using (Pen technoTriggerPen = new Pen(alphaColor, borderSize))
                    using (Font font = graphics.GetAdjustedFont(trigger, SystemFonts.DefaultFont, width, height,
                        Math.Max(1, (int)Math.Round(12 * tileScaleHor)), Math.Max(1, (int)Math.Round(24 * tileScaleHor)), stringFormat, true))
                    {
                        SizeF textBounds = graphics.MeasureString(trigger, font, width, stringFormat);
                        RectangleF backgroundBounds = new RectangleF(bounds.Location, textBounds);
                        backgroundBounds.Offset((width - textBounds.Width) / 2.0f, (height - textBounds.Height) / 2.0f);
                        graphics.FillRectangle(technoTriggerBackgroundBrush, backgroundBounds);
                        graphics.DrawRectangle(technoTriggerPen, Rectangle.Round(backgroundBounds));
                        graphics.DrawString(trigger, font, technoTriggerBrush, realBounds, stringFormat);
                    }
                }
                else
                {
                    int[] indices = Encoding.ASCII.GetBytes(trigger).Select(x => (int)x).ToArray();
                    using (SolidBrush technoTriggerBackgroundBrush = new SolidBrush(Color.FromArgb(96, Color.Black)))
                    using (Pen technoTriggerPen = new Pen(color, 1))
                    using (Bitmap txt = RenderTextFromSprite(classicFont, remapClassicFont, Size.Empty, indices, false, cropClassicFont))
                    using (Bitmap txt2 = new Bitmap(txt.Width + 4, txt.Height + 4))
                    using (ImageAttributes imageAttributes = new ImageAttributes())
                    {
                        txt2.SetResolution(96, 96);
                        using (Graphics txt2g = Graphics.FromImage(txt2))
                        {
                            txt2g.FillRectangle(technoTriggerBackgroundBrush, new Rectangle(1, 1, txt2.Width - 2, txt2.Height - 2));
                            txt2g.DrawRectangle(technoTriggerPen, new Rectangle(0, 0, txt2.Width - 1, txt2.Height - 1));
                            txt2g.DrawImage(txt, new Rectangle(2, 2, txt.Width, txt.Height));
                        }
                        imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, alpha / 256.0f));
                        int paintOffsX = (bounds.Width - txt2.Width) / 2 * tileSize.Width / Globals.OriginalTileWidth;
                        int paintOffsY = (bounds.Height - txt2.Height) / 2 * tileSize.Width / Globals.OriginalTileWidth;
                        int textWidth = txt2.Width * tileSize.Width / Globals.OriginalTileWidth;
                        int textHeight = txt2.Height * tileSize.Width / Globals.OriginalTileWidth;
                        Rectangle paintBounds = new Rectangle(bounds.Location, new Size(textWidth, textHeight));
                        paintBounds.Offset(new Point(paintOffsX, paintOffsY));
                        graphics.DrawImage(txt2, paintBounds, 0, 0, txt2.Width, txt2.Height, GraphicsUnit.Pixel, imageAttributes);
                    }
                }
            }
        }

        public static void RenderWayPointIndicators(Graphics graphics, Map map, GameInfo gameInfo, Rectangle visibleCells, Size tileSize, Color textColor, bool forPreview, bool excludeSpecified, params Waypoint[] specified)
        {
            HashSet<Waypoint> specifiedWaypoints = specified.ToHashSet();

            Waypoint[] toPaint = excludeSpecified ? map.Waypoints : specified;
            string classicFontShort = null;
            bool cropClassicFontShort = false;
            TeamRemap remapClassicFontShort = null;
            string classicFontLong = null;
            bool cropClassicFontLong = false;
            TeamRemap remapClassicFontLong = null;

            if (Globals.TheTilesetManager is TilesetManagerClassic tsmc && Globals.TheTeamColorManager is TeamRemapManager trm)
            {
                classicFontShort = gameInfo.GetClassicFontInfo(ClassicFont.Waypoints, tsmc, trm, textColor, out cropClassicFontShort, out remapClassicFontShort);
                classicFontLong = gameInfo.GetClassicFontInfo(ClassicFont.WaypointsLong, tsmc, trm, textColor, out cropClassicFontLong, out remapClassicFontLong);
            }
            foreach (Waypoint waypoint in toPaint)
            {
                if ((excludeSpecified && specifiedWaypoints.Contains(waypoint)) || !waypoint.Cell.HasValue
                    || !map.Metrics.GetLocation(waypoint.Cell.Value, out Point topLeft) || !visibleCells.Contains(topLeft))
                {
                    continue;
                }
                Rectangle paintBounds = new Rectangle(new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height), tileSize);
                string wpText = waypoint.Name;
                bool isLong = wpText.Length > 3;
                string classicFont = isLong ? classicFontLong : classicFontShort;
                bool cropClassicFont = isLong ? cropClassicFontLong : cropClassicFontShort;
                TeamRemap remapClassicFont = isLong ? remapClassicFontLong : remapClassicFontShort;
                if (classicFont != null && isLong)
                {
                    wpText = waypoint.ShortName;
                }
                Color backPaintColor = Color.FromArgb(128, Color.Black);
                // Adjust calcuations to tile size. The below adjustments are done assuming the tile is 128 wide.
                double tileScaleHor = tileSize.Width / 128.0;
                using (SolidBrush baseBackgroundBrush = new SolidBrush(backPaintColor))
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, forPreview ? 0.5f : 1.0f));
                    if (classicFont == null)
                    {
                        StringFormat stringFormat = new StringFormat
                        {
                            Alignment = StringAlignment.Center,
                            LineAlignment = StringAlignment.Center
                        };
                        using (SolidBrush baseTextBrush = new SolidBrush(Color.FromArgb(forPreview ? 128 : 255, textColor)))
                        using (Font font = graphics.GetAdjustedFont(wpText, SystemFonts.DefaultFont, paintBounds.Width, paintBounds.Height,
                            Math.Max(1, (int)Math.Round(12 * tileScaleHor)), Math.Max(1, (int)Math.Round(55 * tileScaleHor)), stringFormat, true))
                        {
                            SizeF textBounds = graphics.MeasureString(wpText, font, paintBounds.Width, stringFormat);
                            RectangleF backgroundBounds = new RectangleF(paintBounds.Location, textBounds);
                            backgroundBounds.Offset((paintBounds.Width - textBounds.Width) / 2.0f, (paintBounds.Height - textBounds.Height) / 2.0f);
                            graphics.FillRectangle(baseBackgroundBrush, backgroundBounds);
                            graphics.DrawString(wpText, font, baseTextBrush, backgroundBounds, stringFormat);
                        }
                    }
                    else
                    {
                        string wpId = "waypoint_" + wpText + "_" + classicFont + "_" + remapClassicFont.Name;
                        Bitmap wpBm = Globals.TheShapeCacheManager.GetImage(wpId);
                        if (wpBm == null)
                        {
                            wpBm = new Bitmap(tileSize.Width, tileSize.Height);
                            int[] indices = Encoding.ASCII.GetBytes(wpText).Select(x => (int)x).ToArray();
                            using (Graphics bmgr = Graphics.FromImage(wpBm))
                            using (Bitmap txt = RenderTextFromSprite(classicFont, remapClassicFont, Size.Empty, indices, false, cropClassicFont))
                            {
                                int textOffsetX = (tileSize.Width - txt.Width) / 2;
                                int textOffsetY = (tileSize.Height - txt.Height) / 2;
                                int frameOffsetX = Math.Max(textOffsetX, -tileSize.Width) - 1;
                                int frameOffsetY = Math.Max(textOffsetY, -tileSize.Height) - 1;
                                int frameWidth = Math.Min(txt.Width + 2, tileSize.Width * 3);
                                int frameHeight = Math.Min(txt.Height + 2, tileSize.Height * 3);
                                Rectangle frameRect = new Rectangle(frameOffsetX, frameOffsetY, frameWidth, frameHeight);
                                Rectangle textRect = new Rectangle(textOffsetX, textOffsetY, txt.Width, txt.Height);
                                bmgr.FillRectangle(baseBackgroundBrush, frameRect);
                                bmgr.DrawImage(txt, textRect, 0, 0, txt.Width, txt.Height, GraphicsUnit.Pixel);
                            }
                        }
                        Globals.TheShapeCacheManager.AddImage(wpId, wpBm);
                        Rectangle paintRect = new Rectangle(paintBounds.Location.X, paintBounds.Location.Y, wpBm.Width, wpBm.Height);
                        graphics.DrawImage(wpBm, paintRect, 0, 0, wpBm.Width, wpBm.Height, GraphicsUnit.Pixel, imageAttributes);
                    }
                }
            }
        }

        public static void RenderAllBuildingEffectRadiuses(Graphics graphics, Map map, Rectangle visibleCells, Size tileSize, int effectRadius, Building selected)
        {
            foreach ((Point topLeft, Building building) in map.Buildings.OfType<Building>()
                .Where(b => (b.Occupier.Type.Flag & BuildingTypeFlag.GapGenerator) != BuildingTypeFlag.None))
            {
                RenderBuildingEffectRadius(graphics, visibleCells, tileSize, effectRadius, building, topLeft, selected);
            }
        }

        public static void RenderBuildingEffectRadius(Graphics graphics, Rectangle visibleCells, Size tileSize, int effectRadius, Building building, Point topLeft, Building selected)
        {
            if ((building.Type.Flag & BuildingTypeFlag.GapGenerator) != BuildingTypeFlag.GapGenerator)
            {
                return;
            }
            ITeamColor tc = Globals.TheTeamColorManager[building.House?.BuildingTeamColor];
            Color circleColor = Globals.TheTeamColorManager.GetBaseColor(tc?.Name);
            bool[,] cells = building.Type.BaseOccupyMask;
            int maskY = cells.GetLength(0);
            int maskX = cells.GetLength(1);
            Rectangle circleCellBounds = GeneralUtils.GetBoxFromCenterCell(topLeft, maskX, maskY, effectRadius, effectRadius, new Size(1,1), out _);
            Rectangle circleBounds = GeneralUtils.GetBoxFromCenterCell(topLeft, maskX, maskY, effectRadius, effectRadius, tileSize, out Point center);
            if (visibleCells.IntersectsWith(circleCellBounds))
            {
                float alphaFactor = 1.0f;
                if (building.IsPreview)
                {
                    alphaFactor *= Globals.PreviewAlphaFloat;
                }
                if (!building.IsPrebuilt)
                {
                    alphaFactor *= Globals.UnbuiltAlphaFloat;
                }
                int alphaFactorInt = (int)Math.Round(alphaFactor * 256).Restrict(0, 255);
                Color alphacorr = Color.FromArgb(alphaFactorInt, circleColor);
                RenderCircleDiagonals(graphics, tileSize, alphacorr, effectRadius, effectRadius, center);
                DrawDashesCircle(graphics, circleBounds, tileSize, alphacorr, true, -1.25f, 2.5f);
            }
        }

        public static void RenderAllUnitEffectRadiuses(Graphics graphics, Map map, Rectangle visibleCells, Size tileSize, int jamRadius, Unit selected)
        {
            foreach ((Point topLeft, Unit unit) in map.Technos.OfType<Unit>()
                .Where(b => (b.Occupier.Type.Flag & (UnitTypeFlag.IsGapGenerator | UnitTypeFlag.IsJammer)) != UnitTypeFlag.None))
            {
                RenderUnitEffectRadius(graphics, tileSize, jamRadius, unit, topLeft, visibleCells, selected);
            }
        }

        public static void RenderUnitEffectRadius(Graphics graphics, Size tileSize, int jamRadius, Unit unit, Point cell, Rectangle visibleCells, Unit selected)
        {
            bool isJammer = unit.Type.Flag.HasFlag(UnitTypeFlag.IsJammer);
            bool isGapGen = unit.Type.Flag.HasFlag(UnitTypeFlag.IsGapGenerator);
            if (!isJammer && !isGapGen)
            {
                return;
            }
            ITeamColor tc = Globals.TheTeamColorManager[unit.House?.BuildingTeamColor];
            Color circleColor = Globals.TheTeamColorManager.GetBaseColor(tc?.Name);
            float alphaFactor = 1.0f;
            if (unit.IsPreview)
            {
                alphaFactor *= Globals.PreviewAlphaFloat;
            }
            int alphaFactorInt = (int)Math.Round(alphaFactor * 256).Restrict(0, 255);
            Color alphacorr = Color.FromArgb(alphaFactorInt, circleColor);
            if (isJammer)
            {
                // uses map's Gap Generator range.
                Rectangle circleCellBounds = GeneralUtils.GetBoxFromCenterCell(cell, 1, 1, jamRadius, jamRadius, new Size(1, 1), out _);
                Rectangle circleBounds = GeneralUtils.GetBoxFromCenterCell(cell, 1, 1, jamRadius, jamRadius, tileSize, out Point center);
                if (visibleCells.IntersectsWith(circleCellBounds))
                {
                    RenderCircleDiagonals(graphics, tileSize, alphacorr, jamRadius, jamRadius, center);
                    DrawDashesCircle(graphics, circleBounds, tileSize, alphacorr, true, -1.25f, 2.5f);
                }
            }
            if (isGapGen)
            {
                // uses specific 5x7 circle around the unit cell
                int radiusX = 2;
                int radiusY = 3;
                Rectangle circleCellBounds = GeneralUtils.GetBoxFromCenterCell(cell, 1, 1, radiusX, radiusY, new Size(1, 1), out _);
                Rectangle circleBounds = GeneralUtils.GetBoxFromCenterCell(cell, 1, 1, radiusX, radiusY, tileSize, out Point center);
                if (visibleCells.IntersectsWith(circleCellBounds))
                {
                    RenderCircleDiagonals(graphics, tileSize, alphacorr, radiusX, radiusY, center);
                    DrawDashesCircle(graphics, circleBounds, tileSize, alphacorr, true, -1.25f, 2.5f);
                }
            }
        }

        private static void RenderCircleDiagonals(Graphics graphics, Size tileSize, Color paintColor, double radiusX, double radiusY, Point center)
        {

            float penSize = Math.Max(1.0f, tileSize.Width / 16.0f);
            using (Pen linePen = new Pen(paintColor, penSize))
            {
                linePen.DashPattern = new float[] { 1.0F, 4.0F, 6.0F, 4.0F };
                linePen.DashCap = DashCap.Round;
                int diamX = (int)Math.Round((radiusX * 2 + 1) * tileSize.Width);
                int radX = diamX / 2;
                int diamY = (int)Math.Round((radiusY * 2 + 1) * tileSize.Height);
                int radY = diamY / 2;
                double sinDistance = Math.Sin(Math.PI * 45 / 180.0);
                int sinX = (int)Math.Round(radX * sinDistance);
                int sinY = (int)Math.Round(radY * sinDistance);
                graphics.DrawLine(linePen, center, new Point(center.X, center.Y - radY));
                graphics.DrawLine(linePen, center, new Point(center.X - sinX, center.Y + sinY));
                graphics.DrawLine(linePen, center, new Point(center.X + radX, center.Y));
                graphics.DrawLine(linePen, center, new Point(center.X + sinX, center.Y + sinX));
                graphics.DrawLine(linePen, center, new Point(center.X, center.Y + radY));
                graphics.DrawLine(linePen, center, new Point(center.X + sinX, center.Y - sinY));
                graphics.DrawLine(linePen, center, new Point(center.X - radX, center.Y));
                graphics.DrawLine(linePen, center, new Point(center.X - sinX, center.Y - sinY));
            }
        }

        public static void RenderAllWayPointRevealRadiuses(Graphics graphics, IGamePlugin plugin, Map map, Rectangle visibleCells, Size tileSize, Waypoint selectedItem)
        {
            RenderAllWayPointRevealRadiuses(graphics, plugin, map, visibleCells, tileSize, selectedItem, false);
        }

        public static void RenderAllWayPointRevealRadiuses(Graphics graphics, IGamePlugin plugin, Map map, Rectangle visibleCells, Size tileSize, Waypoint selectedItem, bool onlySelected)
        {
            int[] wpReveal1 = plugin.GetRevealRadiusForWaypoints(false);
            int[] wpReveal2 = plugin.GetRevealRadiusForWaypoints(true);
            Waypoint[] allWaypoints = map.Waypoints;
            for (int i = 0; i < allWaypoints.Length; i++)
            {
                Waypoint cur = allWaypoints[i];
                bool isSelected = selectedItem != null && selectedItem == cur;
                if (onlySelected && !isSelected)
                {
                    continue;
                }
                Point? p = cur?.Point;
                if (p.HasValue)
                {
                    Color drawColor = isSelected ? Color.Yellow : Color.Orange;
                    if (wpReveal1[i] != 0)
                    {
                        RenderWayPointRevealRadius(graphics, map.Metrics, visibleCells, tileSize, drawColor, isSelected, false, wpReveal1[i], cur);
                    }
                    if (wpReveal2[i] != 0)
                    {
                        RenderWayPointRevealRadius(graphics, map.Metrics, visibleCells, tileSize, drawColor, isSelected, false, wpReveal2[i], cur);
                    }
                }
            }
        }

        public static void RenderWayPointRevealRadius(Graphics graphics, CellMetrics metrics, Rectangle visibleCells, Size tileSize, Color circleColor, bool isSelected, bool forPreview, double revealRadius, Waypoint waypoint)
        {
            if (waypoint.Cell.HasValue && metrics.GetLocation(waypoint.Cell.Value, out Point cellPoint))
            {
                double diam = revealRadius * 2 + 1;
                Rectangle circleCellBounds = new Rectangle(
                    (int)Math.Round(cellPoint.X - revealRadius),
                    (int)Math.Round(cellPoint.Y - revealRadius),
                    (int)Math.Round(diam),
                    (int)Math.Round(diam));
                Rectangle circleBounds = new Rectangle(
                    (int)Math.Round(cellPoint.X * tileSize.Width - revealRadius * tileSize.Width),
                    (int)Math.Round(cellPoint.Y * tileSize.Width - revealRadius * tileSize.Height),
                    (int)Math.Round(diam * tileSize.Width),
                    (int)Math.Round(diam * tileSize.Height));
                if (visibleCells.IntersectsWith(circleCellBounds))
                {
                    DrawDashesCircle(graphics, circleBounds, tileSize, Color.FromArgb(isSelected && !forPreview ? 255 : 128, circleColor), isSelected, 1.25f, 2.5f);
                }
            }
        }

        public static void DrawCircle(Graphics graphics, Rectangle circleBounds, Size tileSize, Color circleColor, bool thickborder)
        {
            float penSize = Math.Max(1f, tileSize.Width / (thickborder ? 16.0f : 32.0f));
            using (Pen circlePen = new Pen(circleColor, penSize))
            {
                graphics.DrawEllipse(circlePen, circleBounds);
            }
        }

        public static void DrawDashesCircle(Graphics graphics, Rectangle circleBounds, Size tileSize, Color circleColor, bool thickborder, float startAngle, float drawAngle)
        {
            float penSize = Math.Max(1f, tileSize.Width / (thickborder ? 16.0f : 32.0f));
            using (Pen circlePen = new Pen(circleColor, penSize))
            {
                drawAngle = Math.Abs(drawAngle);
                float endPoint = 360f + startAngle - drawAngle;
                for (float i = startAngle; i <= endPoint; i += drawAngle * 2)
                {
                    graphics.DrawArc(circlePen, circleBounds, i, drawAngle);
                }
            }
        }

        public static void RenderCellTriggersSoft(Graphics graphics, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, params string[] specifiedToExclude)
        {
            RenderCellTriggers(graphics, gameInfo, map, visibleCells, tileSize, Color.Black, Color.Silver, Color.White, 0.75f, false, true, specifiedToExclude);
        }

        public static void RenderCellTriggersHard(Graphics graphics, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, params string[] specifiedToExclude)
        {
            RenderCellTriggers(graphics, gameInfo, map, visibleCells, tileSize, Color.Black, Color.Silver, Color.White, 1, false, true, specifiedToExclude);
        }

        public static void RenderCellTriggersSelected(Graphics graphics, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, params string[] specifiedToDraw)
        {
            RenderCellTriggers(graphics, gameInfo, map, visibleCells, tileSize, Color.Black, Color.FromArgb(0xFF, 0xC0, 0xC0, 0x00), Color.Yellow, 1, true, false, specifiedToDraw);
        }

        public static void RenderCellTriggers(Graphics graphics, GameInfo gameInfo, Map map, Rectangle visibleCells, Size tileSize, Color fillColor, Color borderColor, Color textColor, double alphaAdjust, bool thickborder, bool excludeSpecified, params string[] specified)
        {
            string classicFont = null;
            bool cropClassicFont = false;
            TeamRemap remapClassicFont = null;
            if (Globals.TheTilesetManager is TilesetManagerClassic tsmc && Globals.TheTeamColorManager is TeamRemapManager trm)
            {
                classicFont = gameInfo.GetClassicFontInfo(ClassicFont.CellTriggers, tsmc, trm, textColor, out cropClassicFont, out remapClassicFont);
            }
            // For bounds, add one more cell to get all borders showing.
            Rectangle boundRenderCells = visibleCells;
            boundRenderCells.Inflate(1, 1);
            boundRenderCells.Intersect(map.Metrics.Bounds);
            HashSet<string> specifiedSet = new HashSet<string>(specified, StringComparer.OrdinalIgnoreCase);
            List<(Point p, CellTrigger cellTrigger)> toRender = new List<(Point p, CellTrigger cellTrigger)>();
            HashSet<string> toRenderSet = new HashSet<string>();
            List<(Point p, CellTrigger cellTrigger)> boundsToDraw = new List<(Point p, CellTrigger cellTrigger)>();
            foreach ((int cell, CellTrigger cellTrigger) in map.CellTriggers.OrderBy(c => c.Cell))
            {
                int x = cell % map.Metrics.Width;
                int y = cell / map.Metrics.Width;
                if (!boundRenderCells.Contains(x, y))
                {
                    continue;
                }
                bool contains = specifiedSet.Contains(cellTrigger.Trigger);
                if (contains && excludeSpecified || !contains && !excludeSpecified)
                {
                    continue;
                }
                // Allow better alpha control by detecting previews but not using that alpha.
                bool isPreview = cellTrigger.IsPreview;
                Point p = new Point(x, y);
                if (visibleCells.Contains(x, y))
                {
                    toRender.Add((p, cellTrigger));
                    toRenderSet.Add(cellTrigger.Trigger + "=" + (isPreview ? 'P' : 'N'));
                }
                boundsToDraw.Add((p, cellTrigger));
            }
            if (boundsToDraw.Count == 0)
            {
                return;
            }
            Color ApplyAlpha(Color col, int baseAlpha, double alphaMul)
            {
                return Color.FromArgb(Math.Max(0, Math.Min(0xFF, (int)Math.Round(baseAlpha * alphaMul, MidpointRounding.AwayFromZero))), col);
            };
            int sizeW = tileSize.Width;
            int sizeH = tileSize.Height;
            // Actual balance is fixed; border is 1, text is 1/2, background is 3/8. The original alpha inside the given colors is ignored.
            // Should probably rewrite this to paint text as opaque on 6/8 alpha background, then paint that as 50% alpha and add solid border,
            // and then paint that with the final adjusted alpha factor.
            fillColor = ApplyAlpha(fillColor, 0x60, alphaAdjust);
            borderColor = ApplyAlpha(borderColor, 0xFF, alphaAdjust);
            textColor = ApplyAlpha(textColor, 0x80, alphaAdjust);
            // for classic fonts
            Color adjustColor = ApplyAlpha(Color.White, 0x80, alphaAdjust);
            // Preview versions
            Color previewFillColor = ApplyAlpha(fillColor, 0x60, alphaAdjust / 2);
            Color previewBorderColor = ApplyAlpha(borderColor, 0xFF, alphaAdjust / 2);
            Color previewTextColor = ApplyAlpha(textColor, 0x80, alphaAdjust / 2);
            // for classic fonts
            Color previewAdjustColor = ApplyAlpha(Color.White, 0x80, alphaAdjust / 2);

            // Render each trigger once, and just paint the rendered image multiple times.
            Dictionary<string, Bitmap> backRenders = new Dictionary<string, Bitmap>();
            Dictionary<string, Bitmap> renders = new Dictionary<string, Bitmap>();
            double tileScaleHor = sizeW / 128.0;
            Rectangle tileBounds = new Rectangle(0, 0, sizeW, sizeH);
            using (SolidBrush prevCellTriggersBackgroundBrush = new SolidBrush(previewFillColor))
            using (SolidBrush prevCellTriggersBrush = new SolidBrush(previewTextColor))
            using (SolidBrush cellTriggersBackgroundBrush = new SolidBrush(fillColor))
            using (SolidBrush cellTriggersBrush = new SolidBrush(textColor))
            {
                foreach (string trigger in toRenderSet)
                {
                    string[] trigPart = trigger.Split('=');
                    if (trigPart.Length != 2)
                    {
                        continue;
                    }
                    string text = trigPart[0];
                    bool isPreview = trigPart[1] == "P";
                    Color textCol = isPreview ? previewTextColor : textColor;
                    Rectangle textBounds = new Rectangle(Point.Empty, tileBounds.Size);
                    string trId = "trigger_" + trigger + "_" + ((uint)(isPreview ? previewTextColor : textColor).ToArgb()).ToString("X4");
                    string bgId = "trig_bg_" + trigger + "_" + ((uint)(isPreview ? previewFillColor : fillColor).ToArgb()).ToString("X4");

                    Bitmap trigbm = Globals.TheShapeCacheManager.GetImage(trId);
                    if (trigbm == null)
                    {
                        trigbm = new Bitmap(sizeW, sizeH);
                        using (Graphics trigctg = Graphics.FromImage(trigbm))
                        {
                            SetRenderSettings(trigctg, classicFont == null);
                            StringFormat stringFormat = new StringFormat
                            {
                                Alignment = StringAlignment.Center,
                                LineAlignment = StringAlignment.Center
                            };
                            using (Bitmap textBm = new Bitmap(sizeW, sizeH))
                            {
                                using (Graphics textGr = Graphics.FromImage(textBm))
                                {
                                    if (classicFont == null)
                                    {
                                        using (Font font = trigctg.GetAdjustedFont(text, SystemFonts.DefaultFont, textBounds.Width, textBounds.Height,
                                            Math.Max(1, (int)Math.Round(24 * tileScaleHor)), Math.Max(1, (int)Math.Round(48 * tileScaleHor)), stringFormat, true))
                                        {
                                            SetRenderSettings(trigctg, true);
                                            // If not set, the text will have ugly black fades at the edges.
                                            textGr.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
                                            textGr.DrawString(text, font, isPreview ? prevCellTriggersBrush : cellTriggersBrush, textBounds, stringFormat);
                                        }
                                    }
                                    else
                                    {
                                        int[] indices = Encoding.ASCII.GetBytes(text).Select(x => (int)x).ToArray();
                                        using (ImageAttributes imageAttributes = new ImageAttributes())
                                        {
                                            imageAttributes.SetColorMatrix(GetColorMatrix(isPreview ? previewAdjustColor : adjustColor, 1.0f, 1.0f));
                                            using (Bitmap txt = RenderTextFromSprite(classicFont, remapClassicFont, tileBounds.Size, indices, false, cropClassicFont))
                                            {
                                                Rectangle paintBounds = new Rectangle(Point.Empty, tileSize);
                                                textGr.DrawImage(txt, textBounds, 0, 0, tileBounds.Width, tileBounds.Height, GraphicsUnit.Pixel, imageAttributes);
                                            }
                                        }
                                    }
                                }
                                trigctg.DrawImage(textBm, 0, 0);
                            }
                        }
                        Globals.TheShapeCacheManager.AddImage(trId, trigbm);
                    }
                    Bitmap fillbm = Globals.TheShapeCacheManager.GetImage(bgId);
                    if (fillbm == null)
                    {
                        fillbm = new Bitmap(sizeW, sizeH);
                        using (Graphics fillctg = Graphics.FromImage(fillbm))
                        {
                            SetRenderSettings(fillctg, classicFont == null);
                            fillctg.FillRectangle(isPreview ? prevCellTriggersBackgroundBrush : cellTriggersBackgroundBrush, textBounds);
                            // Clear background under text to make it more transparent. There are probably more elegant ways to do this, but this works.
                            RegionData textInline = ImageUtils.GetOutline(new Size(sizeW, sizeH), trigbm, 0.00f, (byte)Math.Max(0, textCol.A - 1), false);
                            using (Region clearArea = new Region(textInline))
                            using (Brush clear = new SolidBrush(Color.Transparent))
                            {
                                fillctg.CompositingMode = CompositingMode.SourceCopy;
                                fillctg.FillRegion(clear, clearArea);
                                fillctg.CompositingMode = CompositingMode.SourceOver;
                            }
                        }
                        Globals.TheShapeCacheManager.AddImage(bgId, fillbm);
                    }
                    backRenders.Add(trigger, fillbm);
                    renders.Add(trigger, trigbm);
                }
            }

            var backupCompositingQuality = graphics.CompositingQuality;
            var backupInterpolationMode = graphics.InterpolationMode;
            var backupSmoothingMode = graphics.SmoothingMode;
            var backupPixelOffsetMode = graphics.PixelOffsetMode;
            SetRenderSettings(graphics, classicFont == null);

            foreach ((Point p, CellTrigger cellTrigger) in toRender)
            {
                bool isPreview = cellTrigger.IsPreview;
                string requestName = cellTrigger.Trigger + "=" + (isPreview ? 'P' : 'N');
                if (backRenders.TryGetValue(requestName, out Bitmap fillCtBm))
                {
                    graphics.DrawImage(fillCtBm, p.X * tileSize.Width, p.Y * tileSize.Height);
                }
            }

            float borderSize = Math.Max(0.5f, tileSize.Width / 60.0f);
            float thickBorderSize = Math.Max(1f, tileSize.Width / 20.0f);
            using (Pen prevBorderPen = new Pen(previewBorderColor, thickborder ? thickBorderSize : borderSize))
            using (Pen borderPen = new Pen(borderColor, thickborder ? thickBorderSize : borderSize))
            {
                foreach ((Point p, CellTrigger cellTrigger) in boundsToDraw)
                {
                    bool isPreview = cellTrigger.IsPreview;
                    Rectangle bounds = new Rectangle(new Point(p.X * tileSize.Width, p.Y * tileSize.Height), tileSize);
                    graphics.DrawRectangle(isPreview ? prevBorderPen : borderPen, bounds);
                }
            }
            foreach ((Point p, CellTrigger cellTrigger) in toRender)
            {
                bool isPreview = cellTrigger.IsPreview;
                string requestName = cellTrigger.Trigger + "=" + (isPreview ? 'P' : 'N');
                if (renders.TryGetValue(requestName, out Bitmap ctBm))
                {
                    graphics.DrawImage(ctBm, p.X * tileSize.Width, p.Y * tileSize.Height);
                }
            }
            graphics.CompositingQuality = backupCompositingQuality;
            graphics.InterpolationMode = backupInterpolationMode;
            graphics.SmoothingMode = backupSmoothingMode;
            graphics.PixelOffsetMode = backupPixelOffsetMode;
        }

        public static void RenderMapBoundaries(Graphics graphics, Map map, Rectangle visibleCells, Size tileSize)
        {
            RenderMapBoundaries(graphics, map.Bounds, visibleCells, tileSize, Color.Cyan);
        }

        public static void RenderMapBoundaries(Graphics graphics, Rectangle bounds, Rectangle visibleCells, Size tileSize, Color color)
        {
            // Inflate so you'd see the indicator if it's at the edge.
            visibleCells.Inflate(1, 1);
            Rectangle cropped = bounds;
            cropped.Intersect(visibleCells);
            // If these two are identical, that means all map borders are at least one cell outside the visible cells area.
            if (visibleCells == cropped)
            {
                return;
            }
            Rectangle boundsRect = Rectangle.FromLTRB(
                bounds.Left * tileSize.Width,
                bounds.Top * tileSize.Height,
                bounds.Right * tileSize.Width,
                bounds.Bottom * tileSize.Height
            );
            using (Pen boundsPen = new Pen(color, Math.Max(1f, tileSize.Width / 8.0f)))
            {
                graphics.DrawRectangle(boundsPen, boundsRect);
            }
        }

        public static void RenderMapSymmetry(Graphics graphics, Rectangle bounds, Size tileSize, Color color)
        {
            Rectangle boundsRect = Rectangle.FromLTRB(
                bounds.Left * tileSize.Width,
                bounds.Top * tileSize.Height,
                bounds.Right * tileSize.Width,
                bounds.Bottom * tileSize.Height
            );
            using (Pen boundsPen = new Pen(color, Math.Max(1f, tileSize.Width / 8.0f)))
            {
                graphics.DrawLine(boundsPen, new Point(boundsRect.X, boundsRect.Y), new Point(boundsRect.Right, boundsRect.Bottom));
                graphics.DrawLine(boundsPen, new Point(boundsRect.Right, boundsRect.Y), new Point(boundsRect.X, boundsRect.Bottom));

                int halfX = boundsRect.X + boundsRect.Width / 2;
                int halfY = boundsRect.Y + boundsRect.Height / 2;
                graphics.DrawLine(boundsPen, new Point(halfX, boundsRect.Y), new Point(halfX, boundsRect.Bottom));
                graphics.DrawLine(boundsPen, new Point(boundsRect.X, halfY), new Point(boundsRect.Right, halfY));
            }
        }

        public static void RenderMapGrid(Graphics graphics, Rectangle renderBounds, Rectangle mapBounds, bool mapBoundsRendered, Size tileSize, Color color)
        {
            Rectangle boundvisibleCells = mapBounds;
            boundvisibleCells.Intersect(renderBounds);
            int startY = boundvisibleCells.Y;
            int startX = boundvisibleCells.X;
            int endRight = boundvisibleCells.Right;
            int endBottom = boundvisibleCells.Bottom;
            if (mapBoundsRendered)
            {
                if (boundvisibleCells.Y == mapBounds.Y)
                {
                    startY++;
                }
                if (boundvisibleCells.Bottom == mapBounds.Bottom)
                {
                    endBottom--;
                }
                if (boundvisibleCells.X == mapBounds.X)
                {
                    startX++;
                }
                if (boundvisibleCells.Right == mapBounds.Right)
                {
                    endRight--;
                }
            }
            using (Pen gridPen = new Pen(color, Math.Max(1f, tileSize.Width / 16.0f)))
            {
                int leftBound = boundvisibleCells.X * tileSize.Width;
                int rightBound = boundvisibleCells.Right * tileSize.Width;
                for (int y = startY; y <= endBottom; ++y)
                {
                    int ymul = y * tileSize.Height;
                    graphics.DrawLine(gridPen, new Point(leftBound, ymul), new Point(rightBound, ymul));
                }
                //*/
                int topBound = boundvisibleCells.Y * tileSize.Height;
                int bottomBound = boundvisibleCells.Bottom * tileSize.Height;
                for (int x = startX; x <= endRight; ++x)
                {
                    int xmul = x * tileSize.Height;
                    graphics.DrawLine(gridPen, new Point(xmul, topBound), new Point(xmul, bottomBound));
                }
                //*/
            }
        }

        /// <summary>
        /// Paints the passability grid onto the map.
        /// </summary>
        /// <param name="graphics">Graphics to paint on.</param>
        /// <param name="plugin">Game plugin</param>
        /// <param name="templates">The map data itself</param>
        /// <param name="technos">If given, draws a green grid on the locations of the technos in the given set.</param>
        /// <param name="buildings">If given, draws a green grid on the locations of the buildings in the given set.</param>
        /// <param name="tileSize">Tile size</param>
        /// <param name="visibleCells">If given, only cells in the given area are marked.</param>
        /// <param name="ignoreCells">Cells to completely ignore during the drawing operation.</param>
        /// <param name="forPreview">Indicates this is painted for placement preview purposes, meaning colours with their alpha set to 0 are restored and also handled.</param>
        /// <param name="soft">True to paint the hashing with only 25% alpha instead of the usual 50%.</param>
        public static void RenderHashAreas(Graphics graphics, IGamePlugin plugin, CellGrid<Template> templates, OccupierSet<ICellOccupier> technos, OccupierSet<ICellOccupier> buildings, Size tileSize, Rectangle visibleCells, HashSet<Point> ignoreCells, bool forPreview, bool soft)
        {
            // Check which cells need to be marked.
            LandType clearLand = LandType.Clear;
            // Fetch the terrain type for clear terrain on this theater.
            IEnumerable<Point> points = visibleCells.Points();
            TemplateType clear = plugin.Map.TemplateTypes.Where(t => t.Flag.HasFlag(TemplateTypeFlag.Clear)).FirstOrDefault();
            clearLand = clear.LandTypes.Length > 0 ? clear.LandTypes[0] : LandType.Clear;
            HashSet<LandType> usedLandTypes = plugin.Map.UsedLandTypes;
            if (technos != null && technos.Count() == 0)
            {
                technos = null;
            }
            if (buildings != null && buildings.Count() == 0)
            {
                buildings = null;
            }
            if (templates != null && templates.Length == 0)
            {
                templates = null;
            }
            if (technos == null && buildings != null && templates == null)
            {
                return;
            }
            // Caching this in advance for all types.
            LandType[] landTypes = (LandType[])Enum.GetValues(typeof(LandType));
            int tileWidth = tileSize.Width;
            int tileHeight = tileSize.Height;
            float lineSize = tileWidth / 16.0f;
            int lineOffsetW = tileWidth / 4;
            int lineOffsetH = tileHeight / 4;
            Dictionary<LandType, Color> landColorsMapping = GetLandColorsMapping();
            // If the classic sprite exist, use that and recolour it. Since it's fetched
            // with extension, this will simply not return anything in Remastered mode.
            Globals.TheTilesetManager.GetTileData("trans.icn", 0, out Tile tile);
            // -1 and 0 are used for respectively partially-filled infantry cells, and fully filled techno cells.
            // But including them in the loop is a lot simpler than extracting the loop process into a function.
            for (int i = -1; i < landTypes.Length; i++)
            {
                LandType landType = LandType.None;
                Color curCol;
                // Techno indication hijacks LandType.None just because it's in this loop.
                bool forTechnos = i <= 0 && (technos != null || buildings != null);
                bool forTechnosPart = forTechnos && i < 0;
                bool forTechnosFull = forTechnos && i == 0;
                if (forTechnosPart)
                {
                    curCol = Globals.HashColorTechnoPart;
                }
                else if (forTechnosFull)
                {
                    curCol = Globals.HashColorTechnoFull;
                }
                else
                {
                    if (i <= 0 || templates == null)
                    {
                        continue;
                    }
                    landType = landTypes[i];
                    if (!usedLandTypes.Contains(landType) || !landColorsMapping.TryGetValue(landType, out curCol))
                    {
                        continue;
                    }
                }
                // Unless it's for a placement preview, terrain types with a colour that is fully transparent are completely skipped.
                if (curCol.A == 0 && !forPreview)
                {
                    continue;
                }
                curCol = Color.FromArgb(255, curCol);
                string hashId = "hashing_" + tileWidth + "x" + tileHeight + "_" + ((uint)curCol.ToArgb()).ToString("X4");
                Bitmap hashBmp = Globals.TheShapeCacheManager.GetImage(hashId);
                if (hashBmp == null)
                {
                    hashBmp = GenerateLinesBitmap(tile, tileWidth, tileHeight, curCol, lineSize, lineOffsetW, lineOffsetH, graphics);
                    Globals.TheShapeCacheManager.AddImage(hashId, hashBmp);
                }
                using (ImageAttributes imageAttributes = new ImageAttributes())
                {
                    imageAttributes.SetColorMatrix(GetColorMatrix(Color.White, 1.0f, soft ? 0.25f : 0.50f));
                    for (int y = visibleCells.Y; y < visibleCells.Bottom; ++y)
                    {
                        for (int x = visibleCells.X; x < visibleCells.Right; ++x)
                        {
                            if (ignoreCells != null && ignoreCells.Contains(new Point(x, y)))
                            {
                                continue;
                            }
                            bool renderTerrainType = templates != null;
                            if (technos != null || buildings != null)
                            {
                                ICellOccupier techno = technos?[y, x];
                                ICellOccupier building = buildings?[y, x];
                                bool isBuilding;
                                if (building is Building bld)
                                {
                                    // Point fetch will always succeed, since the building comes from that list.
                                    Point pt = buildings[bld].Value;
                                    // Offset relative to building orgin point
                                    int bldCellX = x - pt.X;
                                    int bldCellY = y - pt.Y;
                                    Size size = bld.Size;
                                    // Check if inside BaseOccupyMask. If not, it's just bib or extra refresh area, so ignore.
                                    isBuilding = bldCellX < size.Width && bldCellY < size.Height && bld.BaseOccupyMask[bldCellY, bldCellX];
                                }
                                else
                                {
                                    // Solid overlays in the buildings list.
                                    isBuilding = building != null;
                                }
                                bool isTechno = techno != null || isBuilding;
                                // Skip if it's a techno-loop and there's no techno,
                                // or if it's not a techno-loop and there is a techno (to avoid overlap).
                                if ((forTechnos && !isTechno) || (!forTechnos && isTechno))
                                {
                                    continue;
                                }
                                if (forTechnos && isTechno)
                                {
                                    renderTerrainType = false;
                                    bool incomplete = !isBuilding && techno is InfantryGroup ifg && ifg.Infantry.Any(inf => inf == null);
                                    if (incomplete && forTechnosFull || !incomplete && forTechnosPart)
                                    {
                                        continue;
                                    }
                                }
                            }
                            if (renderTerrainType)
                            {
                                Template template = templates[y, x];
                                LandType land = LandType.None;
                                land = template == null ? clearLand : template.Type.GetLandType(template.Icon);
                                // Only handle currently looped one
                                if (land != landType)
                                {
                                    continue;
                                }
                            }
                            graphics.DrawImage(hashBmp, new Rectangle(tileWidth * x, tileHeight * y, tileWidth, tileHeight),
                                0, 0, hashBmp.Width, hashBmp.Height, GraphicsUnit.Pixel, imageAttributes);
                        }
                    }
                }
            }
        }

        private static Dictionary<LandType, Color> GetLandColorsMapping()
        {
            return new Dictionary<LandType, Color>
            {
                {LandType.Clear, Globals.HashColorLandClear }, // [Clear] Normal clear terrain.
                {LandType.Beach, Globals.HashColorLandBeach }, // [Beach] Sandy beach. Can't be built on.
                {LandType.Rock,  Globals.HashColorLandRock }, //  [Rock]  Impassable terrain.
                {LandType.Road,  Globals.HashColorLandRoad }, //  [Road]  Units move faster on this terrain.
                {LandType.Water, Globals.HashColorLandWater }, // [Water] Ships can travel over this.
                {LandType.River, Globals.HashColorLandRiver }, // [River] Ships normally can't travel over this.
                {LandType.Rough, Globals.HashColorLandRough }, // [Rough] Rough terrain. Can't be built on
            };
        }

        /// <summary>
        /// Generates a cell filled with diagonal line hashing. If a tile is given, and it matches the requested size,
        /// it used to generate the result by recolouring all its non-transparent pixels with the requested color.
        /// </summary>
        /// <param name="tile">Tile to use graphics from, if available.</param>
        /// <param name="width">Width of the resulting image.</param>
        /// <param name="height">Height of the resulting image.</param>
        /// <param name="color">Color of the resulting image.</param>
        /// <param name="lineSize">Thickness of the lines to paint.</param>
        /// <param name="lineOffsetW">Horizontal offset between each line.</param>
        /// <param name="lineOffsetH">Vertical offset between each line.</param>
        /// <param name="g">Graphics object to copy render settings from.</param>
        /// <returns>The image with diagonal lines, in the given color.</returns>
        private static Bitmap GenerateLinesBitmap(Tile tile, int width, int height, Color color, float lineSize, int lineOffsetW, int lineOffsetH, Graphics g)
        {
            if (tile != null && tile.Image != null)
            {
                byte colR = color.R;
                byte colG = color.G;
                byte colB = color.B;
                byte[] imgData = ImageUtils.GetImageData(tile.Image, out int stride, PixelFormat.Format32bppArgb, true);
                // Replace colors, retain alpha.
                for (int i = 0; i < imgData.Length; i += 4)
                {
                    // Only replace non-transparent pixels
                    if (imgData[i + 3] == 0)
                    {
                        continue;
                    }
                    // ARGB = [BB GG RR AA]
                    imgData[i + 0] = colB;
                    imgData[i + 1] = colG;
                    imgData[i + 2] = colR;
                }
                if (tile.Image.Width == width && tile.Image.Height == height)
                {
                    return ImageUtils.BuildImage(imgData, width, height, stride, PixelFormat.Format32bppArgb, null, null);
                }
                else
                {
                    using (Bitmap tmp = ImageUtils.BuildImage(imgData, tile.Image.Width, tile.Image.Height, stride, PixelFormat.Format32bppArgb, null, null))
                    {
                        Bitmap bm = new Bitmap(width, height);
                        using (Graphics bmg = Graphics.FromImage(bm))
                        {
                            // Pixel upscale for classic graphics
                            SetRenderSettings(bmg, false);
                            bmg.DrawImage(tmp, new Rectangle(0, 0, width, height), 0, 0, tmp.Width, tmp.Height, GraphicsUnit.Pixel);
                        }
                        return bm;
                    }
                }
            }
            Bitmap bitmap = new Bitmap(width, height);
            int tripleWidth = width * 3;
            int tripleHeight = height * 3;
            bool hardLines = g != null && g.InterpolationMode == InterpolationMode.NearestNeighbor;
            int nrOfLines = 1;
            if (hardLines)
            {
                nrOfLines = Math.Max(1, (int)Math.Round(lineSize));
            }
            using (Bitmap img = new Bitmap(tripleWidth, tripleHeight))
            {
                using (Graphics gr = Graphics.FromImage(img))
                using (SolidBrush sb = new SolidBrush(color))
                using (Pen p = new Pen(sb, hardLines ? 1 : lineSize))
                {
                    if (g != null)
                    {
                        CopyRenderSettingsFrom(gr, g);
                    }
                    int offsetX = lineOffsetW;
                    int offsetY = lineOffsetH;
                    int hexWidth = width * 6;
                    int hexHeight = height * 6;
                    while (offsetX <= hexWidth && offsetY <= hexHeight)
                    {
                        // Paint lines
                        for (int i = 0; i < nrOfLines; i++)
                        {
                            gr.DrawLine(p, offsetX + i, 0, 0, offsetY + i);
                        }
                        offsetX += lineOffsetW;
                        offsetY += lineOffsetH;
                    }
                }
                using (Graphics gr = Graphics.FromImage(bitmap))
                {
                    if (g != null)
                    {
                        CopyRenderSettingsFrom(gr, g);
                    }
                    gr.DrawImage(img, new Rectangle(0, 0, width, height), width, height, width, height, GraphicsUnit.Pixel);
                    // Paint lines image on final image.
                }
            }
            return bitmap;
        }

        public static void SetRenderSettings(Graphics g, bool smooth)
        {
            if (smooth)
            {
                g.CompositingQuality = CompositingQuality.HighQuality;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.PixelOffsetMode = PixelOffsetMode.HighQuality;
            }
            else
            {
                g.CompositingQuality = CompositingQuality.AssumeLinear;
                g.InterpolationMode = InterpolationMode.NearestNeighbor;
                g.SmoothingMode = SmoothingMode.None;
                g.PixelOffsetMode = PixelOffsetMode.Half;
            }
        }

        public static void CopyRenderSettingsFrom(this Graphics target, Graphics source)
        {
            target.CompositingQuality = source.CompositingQuality;
            target.InterpolationMode = source.InterpolationMode;
            target.SmoothingMode = source.SmoothingMode;
            target.PixelOffsetMode = source.PixelOffsetMode;
        }

        public static Rectangle RenderBounds(Size imageSize, Size cellDimensions, Size cellSize)
        {
            double scaleFactorX = cellSize.Width / (double)Globals.OriginalTileWidth;
            double scaleFactorY = cellSize.Height / (double)Globals.OriginalTileHeight;
            return RenderBounds(imageSize, cellDimensions, scaleFactorX, scaleFactorY);
        }

        public static Rectangle RenderBounds(Size imageSize, Size cellDimensions, double scaleFactor)
        {
            return RenderBounds(imageSize, cellDimensions, scaleFactor, scaleFactor);
        }

        public static Rectangle RenderBounds(Size imageSize, Size cellDimensions, double scaleFactorX, double scaleFactorY)
        {
            Size maxSize = new Size(cellDimensions.Width * Globals.OriginalTileWidth, cellDimensions.Height * Globals.OriginalTileHeight);
            // If graphics are too large, scale them down using the largest dimension
            Size newSize = new Size(imageSize.Width, imageSize.Height);
            if ((imageSize.Width >= imageSize.Height) && (imageSize.Width > maxSize.Width))
            {
                newSize.Height = imageSize.Height * maxSize.Width / imageSize.Width;
                newSize.Width = maxSize.Width;
            }
            else if ((imageSize.Height >= imageSize.Width) && (imageSize.Height > maxSize.Height))
            {
                newSize.Width = imageSize.Width * maxSize.Height / imageSize.Height;
                newSize.Height = maxSize.Height;
            }
            // center graphics inside bounding box
            int locX = (maxSize.Width - newSize.Width) / 2;
            int locY = (maxSize.Height - newSize.Height) / 2;
            return new Rectangle((int)Math.Round(locX * scaleFactorX), (int)Math.Round(locY * scaleFactorY),
                Math.Max(1, (int)Math.Round(newSize.Width * scaleFactorX)), Math.Max(1, (int)Math.Round(newSize.Height * scaleFactorY)));
        }

        private static Bitmap RenderTextFromSprite(string fontsprite, TeamRemap remap, Size bounds, int[] shapes, bool wrap, bool cropSpacingToOne)
        {
            int nrOfChars = shapes.Length;
            if (nrOfChars == 0)
            {
                return null;
            }
            Tile[] tiles = new Tile[nrOfChars];
            int[] offsets = new int[nrOfChars];
            int[] widths = new int[nrOfChars];
            int lineLength = wrap ? 0 : bounds.Width;
            int minTop = -1;
            int maxHeight = bounds.Height;
            int lineSize = 0;
            // Make sure the width of the target image is at least as large as the
            // largest character, to avoid endless loops on line breaks.
            for (int i = 0; i < nrOfChars; ++i)
            {
                int charIndex = shapes[i];
                if (Globals.TheTilesetManager.GetTeamColorTileData(fontsprite, charIndex, remap, true, out Tile character))
                {
                    if (character.Image == null)
                    {
                        continue;
                    }
                    tiles[i] = character;
                    // If cropping is requested, crop character.
                    int charWidth;
                    if (cropSpacingToOne)
                    {
                        Rectangle tileBounds = character.OpaqueBounds;
                        if (tileBounds.Width != 0)
                        {
                            offsets[i] = tileBounds.X;
                            charWidth = tileBounds.Width + 1;
                        }
                        else
                        {
                            charWidth = character.Image.Width;
                        }
                        minTop = minTop == -1 ? tileBounds.Top : Math.Min(minTop, tileBounds.Top);
                        maxHeight = Math.Max(maxHeight, tileBounds.Bottom);
                    }
                    else
                    {
                        charWidth = character.Image.Width;
                        maxHeight = Math.Max(maxHeight, character.Image.Height);
                    }
                    if (i == nrOfChars - 1)
                    {
                        charWidth -= cropSpacingToOne ? 1 : (character.Image.Width - character.OpaqueBounds.Right);
                    }
                    if (wrap)
                    {
                        lineLength = Math.Max(lineLength, charWidth);
                    }
                    else
                    {
                        lineLength += charWidth;
                    }
                    widths[i] = charWidth;
                    lineSize = Math.Max(lineSize, character.Image.Height);
                }
            }
            minTop = Math.Max(minTop, 0);
            int lineHeight = 0;
            int usedWidth = 0;
            int curWidth = 0;
            if (lineLength == 0 || maxHeight - minTop == 0)
            {
                Bitmap bm = new Bitmap(2, 2);
                bm.SetResolution(96, 96);
                return bm;
            }
            Bitmap bitmap = new Bitmap(lineLength, maxHeight - minTop, PixelFormat.Format32bppArgb);
            bitmap.SetResolution(96, 96);
            using (Graphics g = Graphics.FromImage(bitmap))
            {
                for (int i = 0; i < nrOfChars; ++i)
                {
                    Tile curChar = tiles[i];
                    if (curChar == null)
                    {
                        continue;
                    }
                    usedWidth = Math.Max(usedWidth, curWidth);
                    if (curWidth >= lineLength)
                    {
                        lineHeight += lineSize;
                        if (lineHeight >= maxHeight)
                        {
                            break;
                        }
                        usedWidth = Math.Max(usedWidth, curWidth);
                        curWidth = 0;
                    }
                    if (curChar.Image == null)
                    {
                        continue;
                    }
                    int nextWidth = curWidth + widths[i];
                    if (nextWidth > lineLength)
                    {
                        lineHeight += lineSize;
                        if (lineHeight >= maxHeight)
                        {
                            break;
                        }
                        curWidth = 0;
                    }
                    else
                    {
                        usedWidth = Math.Max(usedWidth, nextWidth);
                    }
                    g.DrawImage(curChar.Image, curWidth - offsets[i], lineHeight - minTop);
                    curWidth = nextWidth;
                }
            }
            lineHeight += lineSize;
            // Chop off if it exceeds bounds.
            if (!bounds.IsEmpty && (lineLength > bounds.Width || maxHeight > bounds.Height || lineHeight < bounds.Height || usedWidth < bounds.Width))
            {
                Bitmap curBm = bitmap;
                Bitmap newBm = new Bitmap(bounds.Width, bounds.Height, PixelFormat.Format32bppArgb);
                int height = Math.Max((bounds.Height - lineHeight) / 2, 0);
                int width = Math.Max((bounds.Width - usedWidth) / 2, 0);
                using (Graphics g = Graphics.FromImage(newBm)) {
                    g.DrawImage(curBm, width, height);
                }
                try { curBm.Dispose(); }
                catch { /* ignore */ }
                bitmap = newBm;
            }
            return bitmap;
        }

        private static ColorMatrix GetColorMatrix(Color tint, float brightnessModifier, float alphaModifier)
        {
            return new ColorMatrix(new float[][]
            {
                new float[] {tint.R * brightnessModifier / 255.0f, 0, 0, 0, 0},
                new float[] {0, tint.G * brightnessModifier / 255.0f, 0, 0, 0},
                new float[] {0, 0, tint.B * brightnessModifier / 255.0f, 0, 0},
                new float[] {0, 0, 0, tint.A * alphaModifier / 255.0f, 0},
                new float[] {0, 0, 0, 0, 1},
            });
        }
    }
}