source: 2010/23/hniemi/BlockPusher/Blockpusher/Blockpusher/BlockLevel.cs @ 2635

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

/// <summary>
/// Class that holds information of level and players location
/// Also handles movement of player.
/// </summary>
public class BlockLevel
{
    private Block[,] playfield;
    private Blockpusher game;
    private List<Tuple<char, BlockType>> charcolors = new List<Tuple<char, BlockType>>();
    private List<Block> goals = new List<Block>();

    private int playerX;
    private int playerY;

    public delegate void GameEvent();
    public event GameEvent Victory;

    /// <summary>
    /// Height of the playfield
    /// </summary>
    public int PlayfieldHeight { get { return playfield.GetLength(1); } }
    /// <summary>
    /// Width of the playfield
    /// </summary>
    public int PlayfieldWidth { get { return playfield.GetLength(0); } }

    /// <summary>
    /// Name of the level
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// Constructor from game
    /// </summary>
    /// <param name="game">Game that level is used in</param>
    public BlockLevel(Blockpusher game)
    {
        this.game = game;
        InitCharColors();
    }

    /// <summary>
    /// Adds blocks to game
    /// </summary>
    public void AddToGame()
    {
        game.Level.Size = new Vector(playfield.GetLength(0) * (Blockpusher.BlockSize + 1), playfield.GetLength(1) * (Blockpusher.BlockSize + 1));
        game.Level.CreateBorders();
        for (int i = 0; i < playfield.GetLength(0); i++)
        {
            for (int j = 0; j < playfield.GetLength(1); j++)
            {

                playfield[i, j].X = i * (Blockpusher.BlockSize + 1) + game.Level.Left + (Blockpusher.BlockSize / 2);
                playfield[i, j].Y = -(j * (Blockpusher.BlockSize + 1) + game.Level.Bottom + (Blockpusher.BlockSize / 2));
                game.Add(playfield[i,j]);
            }
        }
    }

    /// <summary>
    /// Moves player x and y steps
    /// </summary>
    /// <param name="x">X Movement</param>
    /// <param name="y">Y Movement</param>
    public void MovePlayer(int x, int y)
    {
        switch (Type(playerX + x, playerY + y))
        {
            case BlockType.SatisfiedGoalZone:
            case BlockType.Movable:
                int nextX = playerX + x;
                if (x != 0) { nextX += (x / Math.Abs(x)); }
                int nextY = playerY + y;
                if (y != 0) { nextY += (y / Math.Abs(y)); }
                BlockType t = Type(nextX, nextY);
                if (t == BlockType.Empty || t == BlockType.GoalZone || t == BlockType.SatisfiedGoalZone)
                {
                    Move(playerX + x, playerY + y, nextX, nextY);
                    Move(playerX, playerY, playerX + x, playerY + y);
                    playerX += x;
                    playerY += y;
                }

                break;
            case BlockType.GoalZone:
            case BlockType.Empty:
                Move(playerX, playerY, playerX + x, playerY + y);
                playerX += x;
                playerY += y;
                break;
            default:
                break;
        }

        if (VictoryCheck())
        {
            //TODO Insert Event
            //MessageDisplay.Add("You Win!");
        }
    }

    /// <summary>
    /// Moves block from place a to place b
    /// 
    /// Don't move walls!
    /// </summary>
    /// <param name="startx">Source X coordinate</param>
    /// <param name="starty">Source Y coordinate</param>
    /// <param name="endx">Destination X coordinate</param>
    /// <param name="endy">Destination Y coordinate</param>
    public void Move(int startx, int starty, int endx, int endy)
    {
        //TODO Works, but fugly.
        BlockType destType = playfield[endx, endy].Type;
        BlockType sourType = playfield[startx, starty].Type;
        bool destGoal = playfield[endx, endy].IsGoalZone;
        bool sourGoal = playfield[startx, starty].IsGoalZone;

        if (sourGoal)
        {
            playfield[startx, starty].Type = BlockType.GoalZone;
        }
        else
        {
            playfield[startx, starty].Type = BlockType.Empty;
        }

        if (destGoal)
        {
            if (sourType == BlockType.Player) { playfield[endx, endy].Type = BlockType.Player; }
            if (sourType == BlockType.SatisfiedGoalZone) { playfield[endx, endy].Type = BlockType.SatisfiedGoalZone; }
            if (sourType == BlockType.Movable) { playfield[endx, endy].Type = BlockType.SatisfiedGoalZone; }
        }
        else
        {
            if (sourType == BlockType.Player) { playfield[endx, endy].Type = BlockType.Player; }
            if (sourType == BlockType.SatisfiedGoalZone) { playfield[endx, endy].Type = BlockType.Movable; }
        }
    }

    /// <summary>
    /// Checks if level is completed.
    /// </summary>
    /// <returns></returns>
    public bool VictoryCheck()
    {
        foreach (var item in goals)
        {
            if (!(item.Type == BlockType.SatisfiedGoalZone)) return false;
        }
        if (Victory != null) Victory();
        return true;
    }

    /// <summary>
    /// Initialaizes char->Color-dict.
    /// </summary>
    public void InitCharColors()
    {
        charcolors.Add(new Tuple<char, BlockType>('x', BlockType.UnMovable));
        charcolors.Add(new Tuple<char, BlockType>('b', BlockType.Movable));
        charcolors.Add(new Tuple<char, BlockType>(' ', BlockType.Empty));
        charcolors.Add(new Tuple<char, BlockType>('m', BlockType.GoalZone));
        charcolors.Add(new Tuple<char, BlockType>('p', BlockType.Player));
        charcolors.Add(new Tuple<char, BlockType>('s', BlockType.SatisfiedGoalZone));
    }

    /// <summary>
    /// Finds char matching type.
    /// If not found, return ' '
    /// </summary>
    /// <param name="type">Type you want to find</param>
    /// <returns>Matching char</returns>
    public char FindChar(BlockType type) 
    {
        foreach (var item in charcolors)
        {
            if (item.Item2 == type) return item.Item1;
        }
        return ' ';
    }

    /// <summary>
    /// Finds Blocktype matching char.
    /// If not found, BlockType.Empty is returned.
    /// </summary>
    /// <param name="c">Char you want to find</param>
    /// <returns>Matching type</returns>
    public BlockType FindBlockType(char c)
    {
        foreach (var item in charcolors)
        {
            if (item.Item1 == c) return item.Item2;
        }
        return BlockType.Empty;
    }

    /// <summary>
    /// Creates playfield from given list of strings
    /// </summary>
    /// <param name="level"></param>
    public void CreateField(List<string> level)
    {
        int playfieldWidth = level[0].Length;
        int playfieldHeight = level.Count;

        playfield = new Block[playfieldWidth, playfieldHeight];

        for (int i = 0; i < playfield.GetLength(0); i++)
        {
            for (int j = 0; j < playfield.GetLength(1); j++)
            {
                Block block = new Block(Blockpusher.BlockSize, Blockpusher.BlockSize);
                block.X = i * (Blockpusher.BlockSize + 1) + game.Level.Left + (Blockpusher.BlockSize / 2);
                block.Y = -(j * (Blockpusher.BlockSize + 1) + game.Level.Bottom + (Blockpusher.BlockSize / 2));

                block.Type = FindBlockType(level[j][i]);
                if (block.Type == BlockType.Player)
                {
                    playerX = i;
                    playerY = j;
                }
                if (block.IsGoalZone)
                {
                    goals.Add(block);
                }
                playfield[i, j] = block;
            }
        }
        UpdatePlayer(BlockType.Player);
    }

    /// <summary>
    /// Checks if given coordinates are empty and can be moved to.
    /// 
    /// If coordinates are not in playfield, UnMovable is returned.
    /// </summary>
    /// <param name="x">X-coordinate</param>
    /// <param name="y">Y-coordinate</param>
    /// <returns>State of block at given coordinates</returns>
    public BlockType Type(int x, int y)
    {
        if (x < 0) return BlockType.UnMovable;
        if (y < 0) return BlockType.UnMovable;
        if (x >= PlayfieldWidth) return BlockType.UnMovable;
        if (y >= PlayfieldHeight) return BlockType.UnMovable;

        return playfield[x, y].Type;
    }

    /// <summary>
    /// Returns the current state of level.
    /// </summary>
    /// <returns></returns>
    public List<string> CurrentState() 
    {
        List<string> list = new List<string>();

        for (int i = 0; i < playfield.GetLength(1); i++)
        {
            StringBuilder line = new StringBuilder();
            for (int j = 0; j < playfield.GetLength(0); j++)
            {
                
                line.Append(FindChar(playfield[j,i].Type));
            }
            list.Add(line.ToString());
        }

        return list;
    }

    /// <summary>
    /// Changes color of players coordinates
    /// </summary>
    /// <param name="color">Color</param>
    public void UpdatePlayer(BlockType type)
    {
        playfield[playerX, playerY].Type = type;
    }
}