AbstractTileMap.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace Jypeli
{
    public abstract class AbstractTileMap<TileType>
    {
        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 RouteMethod( List<Vector> route, double width, double height );
 
        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 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 ); } );
        }
    }
}