AbstractTileMap.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

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 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 TileMethodWithPos( Vector position, double width, double height, IntPoint positionInLevelArray);
        public delegate void TileMethodWithPos<T1>(Vector position, double width, double height, IntPoint positionInLevelArray, T1 p1);
        public delegate void TileMethodWithPos<T1, T2>(Vector position, double width, double height, IntPoint positionInLevelArray, T1 p1, T2 p2);
        public delegate void TileMethodWithPos<T1, T2, T3>(Vector position, double width, double height, IntPoint positionInLevelArray, T1 p1, T2 p2, T3 p3);
        public delegate void TileMethodWithPos<T1, T2, T3, T4>(Vector position, double width, double height, IntPoint positionInLevelArray, T1 p1, T2 p2, T3 p3, T4 p4);
        public delegate void TileMethodWithPos<T1, T2, T3, T4, T5>(Vector position, double width, double height, IntPoint positionInLevelArray, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5);
        public delegate void TileMethodWithPos<T1, T2, T3, T4, T5, T6>(Vector position, double width, double height, IntPoint positionInLevelArray, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6);



        struct TileMethodCall
        {
            public TileMethodWithPos method;
            public int row;
            public int col;

            public TileMethodCall( TileMethodWithPos 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, new IntPoint(row, col));
            }
        }

        private List<TileMethodCall> optimized = new List<TileMethodCall>();
        protected Dictionary<TileType, TileMethodWithPos> legend = new Dictionary<TileType, TileMethodWithPos>();
        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, TileMethodWithPos f )
        {
            legend[tileSymbol] = f;
        }

        public void SetTileMethod<T1>( TileType tileSymbol, TileMethodWithPos<T1> f, T1 p1 )
        {
            legend[tileSymbol] = delegate( Vector p, double w, double h, IntPoint posInLevel ) { f( p, w, h, posInLevel, p1 ); };
        }

        public void SetTileMethod<T1, T2>( TileType tileSymbol, TileMethodWithPos<T1, T2> f, T1 p1, T2 p2 )
        {
            legend[tileSymbol] = delegate(Vector p, double w, double h, IntPoint posInLevel) { f(p, w, h, posInLevel, p1, p2); };
        }

        public void SetTileMethod<T1, T2, T3>( TileType tileSymbol, TileMethodWithPos<T1, T2, T3> f, T1 p1, T2 p2, T3 p3 )
        {
            legend[tileSymbol] = delegate(Vector p, double w, double h, IntPoint posInLevel) { f(p, w, h, posInLevel, p1, p2, p3); };
        }

        public void SetTileMethod<T1, T2, T3, T4>(TileType tileSymbol, TileMethodWithPos<T1, T2, T3, T4> f, T1 p1, T2 p2, T3 p3, T4 p4)
        {
            legend[tileSymbol] = delegate(Vector p, double w, double h, IntPoint posInLevel) { f(p, w, h, posInLevel, p1, p2, p3, p4); };
        }

        public void SetTileMethod<T1, T2, T3, T4, T5>(TileType tileSymbol, TileMethodWithPos<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, IntPoint posInLevel) { f(p, w, h, posInLevel, p1, p2, p3, p4, p5); };
        }

        public void SetTileMethod<T1, T2, T3, T4, T5, T6>(TileType tileSymbol, TileMethodWithPos<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, IntPoint posInLevel) { f(p, w, h, posInLevel, p1, p2, p3, p4, p5, p6); };
        }


        public void SetTileMethod( TileType tileSymbol, TileMethod f )
        {
            legend[tileSymbol] = delegate( Vector p, double w, double h, IntPoint posInLevel ) { f( p, w, h ); };
        }

        public void SetTileMethod<T1>( TileType tileSymbol, TileMethod<T1> f, T1 p1 )
        {
            legend[tileSymbol] = delegate( Vector p, double w, double h, IntPoint posInLevel ) { 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, IntPoint posInLevel ) { 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, IntPoint posInLevel ) { 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, IntPoint posInLevel ) { 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, IntPoint posInLevel ) { 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, IntPoint posInLevel ) { f( p, w, h, p1, p2, p3, p4, p5, p6 ); };
        }



        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++ )
                {
                    TileMethodWithPos 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, new IntPoint(x, y));
                    }
                }
            }
        }

        protected TileMethodWithPos 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 )
        {
            TileMethodWithPos 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 )
                    {
                        TileMethodWithPos newMethod = delegate (Vector oldPos, double oldWidth, double oldHeight, IntPoint oldPosInLevel)
                        {
                            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, new IntPoint(row, col));
                        };
                        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 TileMethodWithPos ChangeSize( TileMethodWithPos m, double newWidth, double newHeight )
        {
            return new TileMethodWithPos( delegate( Vector p, double w, double h, IntPoint posInLevel ) { m( p, newWidth, newHeight, posInLevel); } );
        }

        public static TileMethodWithPos ChangeSizeMultiplier( TileMethodWithPos m, double widthMultiplier, double heightMultiplier )
        {
            return new TileMethodWithPos( delegate( Vector p, double w, double h, IntPoint posInLevel) { m( p, w * widthMultiplier, h * heightMultiplier, posInLevel ); } );
        }
    }
}