AbstractTileMap.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace Jypeli
{
    public abstract class AbstractTileMap<TileType>
    {
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
        public delegate void TileMethod(Vector position, double width, double height);
        public delegate void TileMethod<T1>(Vector position, double width, double height, T1 p1);
        public delegate void TileMethod<T1, T2>(Vector position, double width, double height, T1 p1, T2 p2);
        public delegate void TileMethod<T1, T2, T3>(Vector position, double width, double height, T1 p1, T2 p2, T3 p3);
        public delegate void TileMethod<T1, T2, T3, T4>(Vector position, double width, double height, T1 p1, T2 p2, T3 p3, T4 p4);
        public delegate void TileMethod<T1, T2, T3, T4, T5>(Vector position, double width, double height, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5);
        public delegate void TileMethod<T1, T2, T3, T4, T5, T6>(Vector position, double width, double height, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6);
 
        public delegate void RouteMethod(List<Vector> route, double width, double height);
 
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
 
        struct TileMethodCall
        {
            public TileMethod method;
            public int row;
            public int col;
 
            public TileMethodCall(TileMethod m, int row, int col)
            {
                this.method = m;
                this.row = row;
                this.col = col;
            }
 
            public void Invoke(double tileWidth, double tileHeight)
            {
                double realX = Game.Instance.Level.Left + (col * tileWidth) + (tileWidth / 2);
                double realY = Game.Instance.Level.Top - (row * tileHeight) - (tileHeight / 2);
                method(new Vector(realX, realY), tileWidth, tileHeight);
            }
        }
 
        private List<TileMethodCall> optimized = new List<TileMethodCall>();
 
        protected Dictionary<TileType, TileMethod> legend = new Dictionary<TileType, TileMethod>();
 
        protected TileType[,] tiles;
 
        protected abstract TileType Null { get; }
 
        public AbstractTileMap(TileType[,] tiles)
        {
            if (tiles.GetLength(0) == 0 || tiles.GetLength(1) == 0)
                throw new ArgumentException("All dimensions of tiles must be at least 1");
 
            this.tiles = tiles;
        }
 
        public int RowCount
        {
            get { return tiles.GetLength(0); }
        }
 
        public int ColumnCount
        {
            get { return tiles.GetLength(1); }
        }
 
        public void SetTileMethod(TileType tileSymbol, TileMethod f)
        {
            legend[tileSymbol] = f;
        }
 
        public void SetTileMethod<T1>(TileType tileSymbol, TileMethod<T1> f, T1 p1)
        {
            legend[tileSymbol] = delegate (Vector p, double w, double h) { f(p, w, h, p1); };
        }
 
        public void SetTileMethod<T1, T2>(TileType tileSymbol, TileMethod<T1, T2> f, T1 p1, T2 p2)
        {
            legend[tileSymbol] = delegate (Vector p, double w, double h) { f(p, w, h, p1, p2); };
        }
 
        public void SetTileMethod<T1, T2, T3>(TileType tileSymbol, TileMethod<T1, T2, T3> f, T1 p1, T2 p2, T3 p3)
        {
            legend[tileSymbol] = delegate (Vector p, double w, double h) { f(p, w, h, p1, p2, p3); };
        }
 
        public void SetTileMethod<T1, T2, T3, T4>(TileType tileSymbol, TileMethod<T1, T2, T3, T4> f, T1 p1, T2 p2, T3 p3, T4 p4)
        {
            legend[tileSymbol] = delegate (Vector p, double w, double h) { f(p, w, h, p1, p2, p3, p4); };
        }
 
        public void SetTileMethod<T1, T2, T3, T4, T5>(TileType tileSymbol, TileMethod<T1, T2, T3, T4, T5> f, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5)
        {
            legend[tileSymbol] = delegate (Vector p, double w, double h) { f(p, w, h, p1, p2, p3, p4, p5); };
        }
 
        public void SetTileMethod<T1, T2, T3, T4, T5, T6>(TileType tileSymbol, TileMethod<T1, T2, T3, T4, T5, T6> f, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
        {
            legend[tileSymbol] = delegate (Vector p, double w, double h) { f(p, w, h, p1, p2, p3, p4, p5, p6); };
        }
 
        public void SetRouteMethod(RouteMethod f, params TileType[] tileSymbols)
        {
            if (tileSymbols == null || tileSymbols.Length < 1)
                throw new ArgumentException("Pass at least one tile symbol!");
 
            Vector[] vectorTable = new Vector[tileSymbols.Length];
            int vectorsAdded = 0;
 
            for (int i = 0; i < tileSymbols.Length; i++)
            {
                int index = i;
                legend[tileSymbols[i]] = delegate (Vector p, double w, double h)
                {
                    vectorTable[index] = p;
                    if (++vectorsAdded >= tileSymbols.Length)
                        f(vectorTable.ToList(), w, h);
                };
            }
        }
 
        public void Execute()
        {
            double h = Game.Instance.Level.Height / tiles.GetLength(0);
            double w = Game.Instance.Level.Width / tiles.GetLength(1);
            Execute(w, h);
        }
 
        public void Execute(double tileWidth, double tileHeight)
        {
            Game game = Game.Instance;
            int width = tiles.GetLength(1);
            int height = tiles.GetLength(0);
 
            game.Level.Width = width * tileWidth;
            game.Level.Height = height * tileHeight;
 
            foreach (var m in optimized)
            {
                m.Invoke(tileWidth, tileHeight);
            }
 
            for (int y = height - 1; y >= 0; y--)
            {
                for (int x = 0; x < width; x++)
                {
                    TileMethod method = GetMethodForSymbol(tiles[y, x]);
 
                    if (method != null)
                    {
                        double realX = game.Level.Left + (x * tileWidth) + (tileWidth / 2);
                        double realY = game.Level.Top - (y * tileHeight) - (tileHeight / 2);
                        method(new Vector(realX, realY), tileWidth, tileHeight);
                    }
                }
            }
        }
 
        protected TileMethod GetMethodForSymbol(TileType symbol)
        {
            if (symbol.Equals(Null)) return null;
 
            foreach (var key in legend.Keys)
            {
                if (SymbolEquals(key, symbol))
                    return legend[key];
            }
 
            return null;
        }
 
        protected virtual bool SymbolEquals(TileType a, TileType b)
        {
            return a.Equals(b);
        }
 
        public void Optimize(params TileType[] symbols)
        {
            for (int i = 0; i < symbols.Length; i++)
                Optimize(symbols[i]);
        }
 
        public void Optimize(TileType sym)
        {
            TileMethod method = GetMethodForSymbol(sym);
 
            if (method == null)
                throw new ArgumentException("Symbol " + sym + " not added, cannot optimize.");
 
            for (int row = 0; row < RowCount; row++)
            {
                for (int col = 0; col < ColumnCount; col++)
                {
                    int w, h;
                    GetGreatestMatchingRectangle(sym, row, col, out w, out h);
 
                    if (w > 0 && h > 0)
                    {
                        TileMethod newMethod = delegate (Vector oldPos, double oldWidth, double oldHeight)
                        {
                            Vector oldAdjust = new Vector(-oldWidth, oldHeight);
                            Vector newAdjust = new Vector(oldWidth * w, -oldHeight * h);
                            Vector newPos = oldPos + (oldAdjust + newAdjust) / 2;
                            method(newPos, oldWidth * w, oldHeight * h);
                        };
                        optimized.Add(new TileMethodCall(newMethod, row, col));
                        SetArea(row, col, w, h, Null);
                        col += w;
                    }
                }
            }
        }
 
        private void GetGreatestMatchingRectangle(TileType sym, int row, int col, out int width, out int height)
        {
            for (width = 0; width < ColumnCount - col; width++)
            {
                if (!SymbolEquals(tiles[row, col + width], sym))
                    break;
            }
 
            if (width == 0)
            {
                height = 0;
                return;
            }
 
            for (height = 1; height < RowCount - row; height++)
            {
                if (!RowEquals(row + height, col, width, sym))
                    break;
            }
        }
 
        private bool RowEquals(int row, int col, int length, TileType sym)
        {
            for (int i = col; i < col + length; i++)
            {
                if (!SymbolEquals(tiles[row, i], sym)) return false;
            }
 
            return true;
        }
 
        private void SetArea(int row, int col, int width, int height, TileType sym)
        {
            for (int j = row; j < row + height; j++)
            {
                for (int i = col; i < col + width; i++)
                {
                    tiles[j, i] = sym;
                }
            }
        }
 
        public int GetLength(int dimension)
        {
            return tiles.GetLength(dimension);
        }
 
        public TileType GetTile(int row, int col)
        {
            return tiles[row, col];
        }
 
        public void SetTile(int row, int col, TileType c)
        {
            tiles[row, col] = c;
        }
 
        public static TileMethod ChangeSize(TileMethod m, double newWidth, double newHeight)
        {
            return new TileMethod(delegate (Vector p, double w, double h) { m(p, newWidth, newHeight); });
        }
 
        public static TileMethod ChangeSizeMultiplier(TileMethod m, double widthMultiplier, double heightMultiplier)
        {
            return new TileMethod(delegate (Vector p, double w, double h) { m(p, w * widthMultiplier, h * heightMultiplier); });
        }
    }
}