source: 2010/23/hniemi/BlockPusher/Blockpusher/Blockpusher/Blockpusher.cs @ 2632

using System;
using System.Collections.Generic;
using Jypeli;
using Jypeli.Assets;
using Jypeli.Controls;
using Jypeli.Effects;
using Jypeli.Widgets;

public class Blockpusher : Game
{
    private const int blocksize = 20;

    private int playfieldWidth = 20;
    private int playfieldHeight = 20;

    private int playerX = 4;
    private int playerY = 4;


    private Dictionary<char, BlockType> charColor = new Dictionary<char, BlockType>();
    private readonly Color playerColor = Color.Blue;
    private readonly Color satisfyColor = Color.Green;
    private readonly Color unsatisfyColor = Color.Red;

    private List<Block> goals = new List<Block>();

    //[x,y]
    private Block[,] playfield;

    private string[] testLevel = {"xxxxxxxxx",
                                  "x  x  xmx",
                                  "xb s  xbx",
                                  "xm x    x",
                                  "x  xxxxxx",
                                  "x      xx",
                                  "xxxxxxxxx"};

    public override void Begin()
    {
        InitCharColors();
        PhoneBackButton.Listen(ConfirmExit, "Lopeta peli");
        Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, "Lopeta peli");
        CreatePlayfield(testLevel);
        SetControls();
    }

    public void InitCharColors() 
    {
        charColor.Add('x', BlockType.UnMovable);
        charColor.Add('b', BlockType.Movable);
        charColor.Add(' ', BlockType.Empty);
        charColor.Add('m', BlockType.GoalZone);
        charColor.Add('s', BlockType.Player);
    }

    /// <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.Empty:
                Move(playerX, playerY, playerX+x, playerY+y);
                playerX += x;
                playerY += y;
                break;
            default:
                break;
        }

        if (VictoryCheck()) 
        {
            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 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;
    }

    /// <summary>
    /// Creates new gamefield and fills it with blocks.
    /// 
    /// playfieldWidth and playfieldHeight should be set before using this.
    /// </summary>
    public void CreatePlayfield(string[] level)
    {
        playfieldWidth = level[0].Length;
        playfieldHeight = level.Length;
        playfield = new Block[playfieldWidth,playfieldHeight];
        Level.Size = new Vector(playfieldWidth * (blocksize + 1), playfieldHeight * (blocksize + 1));
        Level.CreateBorders();

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

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

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

    /// <summary>
    /// Loads playfield from file
    /// </summary>
    /// <param name="file">Sourcefile</param>
    public void LoadPlayfield(string file) 
    { 
        //TODO Toteuta lukeminen
    }

    /// <summary>
    /// Sets controllisteners for keyboard
    /// </summary>
    public void SetControls() 
    {
        Keyboard.Listen(Key.Up, ButtonState.Pressed, MovePlayer, null, 0, -1);
        Keyboard.Listen(Key.Down, ButtonState.Pressed, MovePlayer, null, 0, 1);
        Keyboard.Listen(Key.Left, ButtonState.Pressed, MovePlayer, null, -1, 0);
        Keyboard.Listen(Key.Right, ButtonState.Pressed, MovePlayer, null, 1, 0);
    }
}