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

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 Dictionary<char, BlockType> charColor = new Dictionary<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>
    /// Constructor from game
    /// </summary>
    /// <param name="game">Game that level is used in</param>
    public BlockLevel(Blockpusher game)
    {
        this.game = game;
        InitCharColors();
    }

    /// <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()
    {
        charColor.Add('x', BlockType.UnMovable);
        charColor.Add('b', BlockType.Movable);
        charColor.Add(' ', BlockType.Empty);
        charColor.Add('m', BlockType.GoalZone);
        charColor.Add('p', BlockType.Player);
        charColor.Add('s', BlockType.SatisfiedGoalZone);
    }

    /// <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];
        game.Level.Size = new Vector(playfieldWidth * (Blockpusher.BlockSize + 1), playfieldHeight * (Blockpusher.BlockSize + 1));
        game.Level.CreateBorders();

        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 = charColor[level[j][i]];
                if (block.Type == BlockType.Player)
                {
                    playerX = i;
                    playerY = j;
                }
                if (block.IsGoalZone)
                {
                    goals.Add(block);
                }
                game.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>
    /// Changes color of players coordinates
    /// </summary>
    /// <param name="color">Color</param>
    public void UpdatePlayer(BlockType type)
    {
        playfield[playerX, playerY].Type = type;
    }
}