ChessBoard.s3d

#ifndef _CHESSBOARD
#define _CHESSBOARD

#include "ChessPiece.s3d"
#include "Animator.s3d"
/*
—— a  b  c  d  e  f  g  h
8 ║56 57 58 59 60 61 62 63
7 ║48 49 50 51 52 53 54 55
6 ║40 41 42 43 44 45 46 47
5 ║32 33 34 35 36 37 38 39
4 ║24 25 26 27 28 29 30 31
3 ║16 17 18 19 20 21 22 23
2 ║ 8  9 10 11 12 13 14 15
1 ║ 0  1  2  3  4  5  6  7
—— a  b  c  d  e  f  g  h
*/
class ChessBoard
{
    var wPieces;
    var bPieces;

    var wMaterial;
    var bMaterial;
    var xMaterial;

    var corner;
    var dimension;

    var eatedCounters;

    var cbMatrix;
    var totalMovesCounter;
    var letters;

    var isDropping;

    var turn;
    var latestMove;
    var enPassant;

    var anim;
    var lb;

    var undoList, undoListSize, undoListHead;

    Init();
    PrintMoveString(turn, type, oldPos, newPos);
    DrawPieces(flag);
    FindTouched(finger, playerColor);
    DropPieces();
    GetPiecePosition(id);
    GetPieceFrom32id(id);
    DropToNewPosition(mov_piece, legalMoves);
    FreeMovePiece(id, pos, legalMoves);
    GetPosFromXY(p);
    GetCenteredPosFromXY(p, dim);

    //given the position of the corner, and dimension of the piece, return the
    // 64 position of the center of the piece
    //GetPosFrom64(pos);

    IsValidDropPosition(id, legalMoves);
    EatPieceIn(pos);
    MovePieceToPos(piece, pos, endTurn);
    LegalMoves(piece, pseudoLegalMoves);
    CanMoveTo(color, dest);
    GenerateFENChessboard();
    GenerateMovetext(oldPos, newPos);
    MakeMovetextMove(movetext);
    SetEnPassant(p, oldPos, newPos);
    CalcNewPos(pos, r, c,  result);
    Conv64ToAH(pos);
    OnFrame();
    EndTurn();

    IsCheck(color, checkPos);
    IsCheckInNewPos(piece, newPos);
    IsCheckMate(color);
    CastlingStatus();
    Castle(king, oldPos);

    AddForUndo(m);
    Undo();
};

function ChessBoard::ChessBoard(c, d, wm, bm, llbb)
{
    wPieces = Array(16);
    bPieces = Array(16);
    wMaterial = wm;
    bMaterial = bm;

    xMaterial = CVmMaterial();
	xMaterial.ambient   = [0.5, 0.5, 0.5, 1.0]; //red
	xMaterial.diffuse   = [1, 0.1, 0.1, 1.0];
	xMaterial.specular  = [0.1, 0.1, 0.1, 0.5];
	//xMaterial.emission = [0.5, 0.1, 0.1];
	xMaterial.shininess = 0;

    corner = c;
    dimension = d;

    letters = {"A", "B", "C", "D", "E", "F", "G", "H"};

    anim = Animator();
    lb = llbb;
}
/*
—— a  b  c  d  e  f  g  h
8 ║♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
7 ║♟ ♟ ♟ ♟ ♟ ♟ ♟ ♟
6 ║… … … … … … … … … … …
5 ║… … … … … … … … … … …
4 ║… … … … … … … … … … …
3 ║… … … … … … … … … … …
2 ║♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
1 ║♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖
—— a  b  c  d  e  f  g  h
*/
//Not working, problem with character encoding
//var bCharP = {"♟","♜","♞","♝","♛","♚"};
//var wCharP = {"♙","♖","♘","♗","♕","♔"};
var bCharP = {"Pawn","Tower","Knight","Bishop","Queen","King"};
var wCharP = bCharP;

function ChessBoard::Init()
{
    totalMovesCounter = 1;
    turn = CP_W;
    eatedCounters = {0,0};
    cbMatrix = Array(64);
    isDropping = false;
    latestMove = null;

    undoListSize = 20;
    undoList = Array(undoListSize);
    undoListHead = 0;

    wPieces[0] = ChessPiece(CP_TOWER, AHto64("A", 1), CP_W, wMaterial);
	wPieces[1] = ChessPiece(CP_TOWER, AHto64("H", 1), CP_W, wMaterial);
	wPieces[2] = ChessPiece(CP_HORSE, AHto64("B", 1), CP_W, wMaterial, false);
	wPieces[3] = ChessPiece(CP_HORSE, AHto64("G", 1), CP_W, wMaterial, true);
	wPieces[4] = ChessPiece(CP_BISHOP, AHto64("C", 1), CP_W, wMaterial);
	wPieces[5] = ChessPiece(CP_BISHOP, AHto64("F", 1), CP_W, wMaterial);
	wPieces[6] = ChessPiece(CP_QUEEN, AHto64("D", 1), CP_W, wMaterial);
	wPieces[7] = ChessPiece(CP_KING, AHto64("E", 1), CP_W, wMaterial);

    for(var i = 0; i < 8; i++)
        wPieces[i+8] = ChessPiece(CP_PAWN, AHto64(letters[i], 2), CP_W, wMaterial);

    bPieces[0] = ChessPiece(CP_TOWER, AHto64("A", 8), CP_B, bMaterial);
	bPieces[1] = ChessPiece(CP_TOWER, AHto64("H", 8), CP_B, bMaterial);
	bPieces[2] = ChessPiece(CP_HORSE, AHto64("B", 8), CP_B, bMaterial, false);
	bPieces[3] = ChessPiece(CP_HORSE, AHto64("G", 8), CP_B, bMaterial, true);
	bPieces[4] = ChessPiece(CP_BISHOP, AHto64("C", 8), CP_B, bMaterial);
	bPieces[5] = ChessPiece(CP_BISHOP, AHto64("F", 8), CP_B, bMaterial);
	bPieces[6] = ChessPiece(CP_QUEEN, AHto64("D", 8), CP_B, bMaterial);
	bPieces[7] = ChessPiece(CP_KING, AHto64("E", 8), CP_B, bMaterial);

    for(var i = 0; i < 8; i++)
        bPieces[i+8] = ChessPiece(CP_PAWN, AHto64(letters[i], 7), CP_B, bMaterial);

    for(var i=0; i<16; i++)
        {
            wPieces[i].SetXYPos(corner, dimension);
            cbMatrix[wPieces[i].position] = wPieces[i];

            bPieces[i].SetXYPos(corner, dimension);
            cbMatrix[bPieces[i].position] = bPieces[i];
            //OutputLN(cbMatrix[32] == Void);

            //for the initial animation
            if(i!=7)
            {
                var wPos = wPieces[i].obj.GetPosition();
                wPieces[i].obj.SetPosition(wPos[0], 50, wPos[2]);
                var bPos = bPieces[i].obj.GetPosition();
                bPieces[i].obj.SetPosition(bPos[0], 50, bPos[2]);
                wPieces[i].isDropping = true;
                bPieces[i].isDropping = true;

                //alternative
                //wPieces[i].SetXYPos([-160, 0, 160], 320);
                //bPieces[i].SetXYPos([-160, 0, 160], 320);

            }
        }
}

function ChessBoard::PrintMoveString(turn, type, oldPos, newPos)
{
    lb.Del();
    var colorMove = turn == CP_W ? "White" : "Black";
    var colorChar = turn == CP_W ? wCharP : bCharP;
    lb.Add(colorMove + " move: " + colorChar[type] + " " + Conv64ToAH(oldpos) + "->" + Conv64ToAH(newPos));
}

function ChessBoard::OnFrame()
{
    DropPieces();
    anim.Update();
}

function ChessBoard::DrawPieces(flag)
{
    for(var i = 0; i<16; i++)
    {
        wPieces[i].Draw(flag);
        bPieces[i].Draw(flag);
    }
}

function ChessBoard::FindTouched(finger, playerColor)
{
    //can touch only own pieces
    var pieces = playerColor == CP_W ? wPieces : bPieces;
    var offset = playerColor == CP_W ? 0 : 16;

    for(var i=0; i<16; i++)
    {
        if(pieces[i].obj.IsCollidingBBox(finger))
            return pieces[i].position != -1 ? i + offset : -1;
            //can touch only non-eated pieces
    }
/*
    for(var i=0; i<16; i++)
    {
        if(wPieces[i].obj.IsCollidingBBox(finger))
            return i;

        if(bPieces[i].obj.IsCollidingBBox(finger))
            return i+16;
    }
*/
    return -1;
}

function CalcDecr(th, drop_step, dist)
{
    var decr  = dist/drop_step;
    if(decr < th)
        decr = th < dist ? th : dist;
    return decr;
}
function ChessBoard::DropPieces()
{
    isDropping = false;
    for(var i = 0; i<32; i++)
    {

        var p = GetPieceFrom32id(i);//i < 16 ? wPieces[i] : bPieces[i-16];
        if(p.isDropping)
        {
            var th = 0.06;
            var  drop_step = 75;
			var pos = p.obj.GetPosition();
            var cbStep = dimension/8;

            var distX = 0;// = ((pos[0]-corner[0]) % cbStep) - p.GetOffSet(dimension);
            var distY = pos[1];
            var distZ = 0;// = ((pos[2]-corner[2]) % cbStep) - p.GetOffSet(dimension);

            if(p.position != -1) //-1 -> the piece is eated
            {
                distX = pos[0] - p.CalcXYPosition(p.position, corner, dimension)[0];//((pos[0]-corner[0]) % cbStep) - p.GetOffSet(dimension);
                distZ = pos[2] - p.CalcXYPosition(p.position, corner, dimension)[2];//((pos[2]-corner[2]) % cbStep) - p.GetOffSet(dimension);
            }

            var decrX = 0.0;
            var decrY = 0.0;
            var decrZ = 0.0;

            if(distX != 0)
            {
                decrX = CalcDecr(0.03, drop_step, distX);

                /*
                if(0.1 < distX)
					decrX = distX/drop_step;
				else
					decrX = distX;
                */
            }
            if(distZ != 0)
            {
                decrZ = CalcDecr(0.03, drop_step, distZ);

            /*
                if(0.1 < distZ)
					decrZ = distZ/drop_step;
				else
					decrZ = distZ;
            */
            }


            if(distY != 0)
			{
                decrY = CalcDecr(th, drop_step, distY);
                /*
                decrY  = distY/drop_step;
                if(decrY < th)
                    decrY = th < distY ? th : distY;
                /*
                if(0.1 < distY) decrY = distY/drop_step;
				else decrY = distY;
                */
                isDropping = true;

                if(distY < 1)
                    p.Promote();
			}

            if(distX + distY + distZ == 0)
            {
                p.isDropping = false;
                p.Promote(); //if I don't rise enough the piece....
            }

            p.obj.SetPosition(pos[0] - decrX, pos[1] - decrY, pos[2] - decrZ);
        }
    }
}

function ChessBoard::IsValidDropPosition(p, legalMoves)
{
    var newPos = GetCenteredPosFromXY(p.obj.GetPosition(), p.myDim);
    //var newPos = GetPosFromXY(p.obj.GetPosition());
    if(newPos < 0 || newPos > 63)
        return false;
    else
        return legalMoves[newPos] != Void;
}

function ChessBoard::DropToNewPosition(id, legalMoves)
{
    var p = GetPieceFrom32id(id);
    var oldPos = p.position;
    cbMatrix[p.position] = Void;
    OutputLN(p.position);
    var newPos = GetCenteredPosFromXY(p.obj.GetPosition(), p.myDim);
    //var newPos = GetPosFromXY(p.obj.GetPosition());

    if(!IsValidDropPosition(p, legalMoves))
        return false;
    else
    {
        p.isDropping = true;
        p.position = newPos;
        OutputLN(p.position);
        //if(cbMatrix[newPos] != Void && cbMatrix[newPos].color != p.color)
            EatPieceIn(newPos);
        cbMatrix[newPos] = p;
        if(oldPos != newPos)
        {
            p.moved++;
            SetEnPassant(p, oldPos, newPos);

            var cr = false;
            if(p.type == CP_KING)
                cr = Castle(p, oldPos);

            latestMove = {totalMovesCounter, turn, GenerateMovetext(oldPos, newPos), p};
            OutputLN(latestMove);

            if(!cr)
                AddForUndo({p, "R", oldPos});

            lb.Del();
            PrintMoveString(turn, p.type, oldPos, newPos);

            EndTurn();
        }
        return true;
    }
}

function ChessBoard::EatPieceIn(pos)
{
    var p = cbMatrix[pos];

    if(enPassant != Void && enPassant[2] == pos)
    {
        p = enPassant[0];
        cbMatrix[p.position] = Void;

    }
    else if(p == Void || p.color == turn) //TODO:
        return;

    OutputLN("Eating piece, enPassant:", enPassant != Void);

    AddForUndo({p, "E", p.position});

    var c = p.color;
    var e = eatedCounters[c];

    var posX = c==CP_W ? corner[0] + (e%8) * 4 : -corner[0] - ((e%8)+1) * 4;
    var posZ = c==CP_W ? corner[2] - 6 - 6 * Int(e/8) : -corner[2] + 2 + 6*Int(e/8);
    //var posX = (c==CP_W ? corner[0] + (e*4)%8 : - corner[0] - (e*4)%8);
    //var posZ = (c==CP_W ? corner[2] - 14 - (e<8?0:4) : - corner[2] + 14 + (e<8?0:4));


    anim.Add(p, -0.6, p.obj.GetPosition(), [posX, 10, posZ], 60);
    //p.isDropping = true;
    //p.obj.SetPosition(posX, 10, posZ);

    eatedCounters[c] = e+1;
    p.position = -1;
    p.moved++;
    //cbMatrix[pos] = Void;
}

function ChessBoard::GetPiecePosition(id)
{
    var p = GetPieceFrom32id(id); //id < 16 ? wPieces[id] : bPieces[id - 16];
    return p.obj.GetPosition();
}

function ChessBoard::FreeMovePiece(id, pos, legalMoves)
{
    var p = GetPieceFrom32id(id); //id < 16 ? wPieces[id] : bPieces[id - 16];
    //TODO: fix, if I move a piece below the board...
    p.obj.SetPosition([pos[0], (pos[1]>0.1? pos[1]: 0.1), pos[2]]);
    if(IsValidDropPosition(p, legalMoves))
        p.obj.ForceMaterial();
    else
        p.obj.ForceMaterial(xMaterial);
}

function ChessBoard::GetPieceFrom32id(id)
{
    return id < 16 ? wPieces[id] : bPieces[id - 16];
}

function ChessBoard::GetPosFromXY(p)
{
    var cbStep = dimension/8;
    var x = Int((p[0]+16) / cbStep);
    var z = Int((p[2]+16) / cbStep);

    return x*8 + z;
}

function ChessBoard::GetCenteredPosFromXY(p, dim)
{
    var cbStep = dimension/8;
    var c = dim/2;
    var x = Int((p[0]+c+16) / cbStep);
    var z = Int((p[2]+c+16) / cbStep);

    return x*8 + z;
}
/* TODO: complete if useful
function ChessBoard::GetPosFrom64(pos, pieceDim)
{
    var row = Int(pos/8);
    var col = pos % 8;

    var x = row * (dimension/8)
}
*/
function ChessBoard::CanMoveTo(color, dest)
{
    if(dest < 0 || dest > 63)
        return false;

    if(cbMatrix[dest] == Void)
        return true;
    else if (cbMatrix[dest].color != color)
        return true;
    else
        return false;
}

function ChessBoard::LegalMoves(p, pseudoLegalMoves)
{
    var startPos = p.position;
    var endPos = startPos;

    var type = p.type;
    var color = p.color;

    var w = (color == CP_W);

    var result = Array(64);
    result[startPos] = 0;

    var tmp;
    if(pseudoLegalMoves == Void)
    {
        pseudoLegalMoves = false;
        OutputLN("WARNING: pseudoLegalMoves is Void");
    }

    switch (type)
    {
        case CP_PAWN: //TODO:en passant
            if(w)
            {
                //forward
                if(CalcNewPos(startPos, 1, 0, &endPos) && cbMatrix[endPos] == Void)// && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos)))//&& CanMoveTo(color, endPos)
                {
                    if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                        result[endPos] = 1;

                    //double forward
                    //little pawn, why are you so special?
                    if(startPos < 16 && CalcNewPos(startPos, 2, 0, &endPos) && cbMatrix[endPos] == Void)//&& CanMoveTo(color, endPos) )// && cbMatrix[endPos-8].color != color)
                        if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                            result[endPos] = 1;
                }

                //left eat
                if(CalcNewPos(startPos, 1, -1, &endPos) && CanMoveTo(color, endPos) && (cbMatrix[endPos] != Void || (enPassant != Void && enPassant[2] == endPos)) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos)))
                    result[endPos] = 1;

                //right eat
                if(CalcNewPos(startPos, 1, 1, &endPos) && CanMoveTo(color, endPos) && (cbMatrix[endPos] != Void || (enPassant != Void && enPassant[2] == endPos))&& (pseudoLegalMoves || !IsCheckInNewPos(p, endPos)))
                    result[endPos] = 1;
            }
            else
            {
                //forward
                if(CalcNewPos(startPos, -1, 0, &endPos)  && cbMatrix[endPos] == Void)// && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos)))// && CanMoveTo(color, endPos))
                {
                    if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                        result[endPos] = 1;

                    //double forward
                    if(startPos > 47  && CalcNewPos(startPos, -2, 0, &endPos)  && cbMatrix[endPos] == Void)//&& CanMoveTo(color, endPos))
                        if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                            result[endPos] = 1;
                }

                //left eat
                if(CalcNewPos(startPos, -1, -1, &endPos) && CanMoveTo(color, endPos) && (cbMatrix[endPos] != Void || (enPassant != Void && enPassant[2] == endPos)) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos)))
                    result[endPos] = 1;

                //right eat
                if(CalcNewPos(startPos, -1, 1, &endPos) && CanMoveTo(color, endPos) && (cbMatrix[endPos] != Void || (enPassant != Void && enPassant[2] == endPos)) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos)))
                    result[endPos] = 1;
            }
            return result;
            break;

        case CP_HORSE:
            //TODO:can I test !IsCheckInNewPos(p, endPos) only the first time?
            if(CalcNewPos(startPos, 1, -2, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            if(CalcNewPos(startPos, 2, -1, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            if(CalcNewPos(startPos, 2, 1, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            if(CalcNewPos(startPos, 1, 2, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            if(CalcNewPos(startPos, -1, 2, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            if(CalcNewPos(startPos, -2, 1, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            if(CalcNewPos(startPos, -2, -1, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            if(CalcNewPos(startPos, -1, -2, &endPos) && CanMoveTo(color, endPos) && (pseudoLegalMoves || !IsCheckInNewPos(p, endPos))) result[endPos] = 1;
            return result;
            break;

        case CP_BISHOP:
        //same as first half of queen, drop down
        case CP_QUEEN:
            //top left
            for(var i = 1; CalcNewPos(startPos, i, -i, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }

            //top right
            for(var i = 1; CalcNewPos(startPos, i, i, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }

            //bottom left
            for(var i = 1; CalcNewPos(startPos, -i, -i, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }

            //bottom right
            for(var i = 1; CalcNewPos(startPos, -i, i, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }
        //don't break or return, we fall down for the others movements shared with rook
        if(type == CP_BISHOP)
            return result;
        case CP_TOWER:
            //left
            for(var i = 1; CalcNewPos(startPos, 0, -i, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }

            //right
            for(var i = 1; CalcNewPos(startPos, 0, i, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }


            //up
            for(var i = 1; CalcNewPos(startPos, i, 0, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }


            //down
            for(var i = 1; CalcNewPos(startPos, -i, 0, &endPos) && CanMoveTo(color, endPos); i++)
            {
                if(pseudoLegalMoves || !IsCheckInNewPos(p, endPos))
                    result[endPos] = 1;
                if(cbMatrix[endPos] != Void && cbMatrix[endPos].color != color)
                    break;//stop at first enemy
            }


            return result;
            break;

        case CP_KING:
            //TODO:better code...

            if(CalcNewPos(startPos, 1, -1, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;
            if(CalcNewPos(startPos, 1, 0, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;
            if(CalcNewPos(startPos, 1, 1, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;
            if(CalcNewPos(startPos, 0, -1, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;
            if(CalcNewPos(startPos, 0, 1, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;
            if(CalcNewPos(startPos, -1, -1, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;
            if(CalcNewPos(startPos, -1, 0, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;
            if(CalcNewPos(startPos, -1, 1, &endPos) && CanMoveTo(color, endPos) && !IsCheckInNewPos(p, endPos)) result[endPos] = 1;


            //castling
            tmp = CastlingStatus();

            if(w)
            {
                if(CalcNewPos(startPos, 0, 2, &endPos) && tmp[0]) result[endPos] = 1;
                if(CalcNewPos(startPos, 0, -2, &endPos) && tmp[1]) result[endPos] = 1;
            }
            else
            {
                if(CalcNewPos(startPos, 0, 2, &endPos) && tmp[2]) result[endPos] = 1;
                if(CalcNewPos(startPos, 0, -2, &endPos) && tmp[3]) result[endPos] = 1;
            }


            return result;
            break;
    }
}

//Given a position, and a increment in rows and colums, write new position
//in result, and retur true if valid, false ow
function ChessBoard::CalcNewPos(pos, r, c, result)
{
        var startRow = Int(pos/8);
        var starCol = pos % 8;

        var endRow = startRow + r;
        var endCol = starCol  + c;

        result = endRow * 8 + endCol;

        if(endRow < 0 || endCol > 7 || endCol < 0 || endRow > 7)
            return false;
        else
            return true;
}


function ChessBoard::GenerateFENChessboard()
{
    var pieceToFEN = {"P","R","N","B","Q","K"};
    var string = "";
    for(var rank = 7; rank >= 0; rank--)
    {
        for (var i = 0; i < 8 ; i++)
        {
            var pos = rank * 8 + i;
            var p = cbMatrix[pos];

            if(p == Void)
                string += "1";
            else if(p.color == CP_W)
                string += pieceToFEN[p.type];
            else
                string += lower(pieceToFEN[p.type]);
        }

        if(rank != 0)
            string += "/";
    }
    if(turn == CP_W)
        string += " w ";
    else
        string += " b ";

    //castling
    var cStatus = CastlingStatus();
    if(!cStatus[0] && !cStatus[1] && !cStatus[2] && !cStatus[3])
        string += "-";
    else
    {
        if(cStatus[0]) string += "K";
        if(cStatus[1]) string += "Q";
        if(cStatus[2]) string += "k";
        if(cStatus[3]) string += "q";
    }

    //en passant target square
    if(enPassant != Void)
        string += (" " + enPassant[1]);
    else
        string += " -";


    //half move counter
    string += " 0";

    //total moves counter
    string += Sprintf(" %d", totalMovesCounter);

    return string;
}

function ChessBoard::GenerateMovetext(oldPos, newPos)
{
    var start = Conv64ToAH(oldPos);
    var end = Conv64ToAH(newPos);

    return Sprintf("%s%s", start, end);
}

function ChessBoard::MakeMovetextMove(movetext)
{
    OutputLN("Making move: ", movetext);
    var highlightSquares = Array(64);
    var startPos = AHto64(movetext[0], val(movetext[1]));
    var endPos = AHto64(movetext[2], val(movetext[3]));
    highlightSquares[startPos] = 1;
    highlightSquares[endPos] = 1;
    AddForUndo({cbMatrix[startPos], "R", startPos}); //TODO: enemy castling
    MovePieceToPos(cbMatrix[startPos], endPos, true);
    return highlightSquares;
}

function ChessBoard::MovePieceToPos(p, newPos, end)
{
    var oldPos = p.position;
    cbMatrix[p.position] = Void;
    p.position = newPos;
    //if(cbMatrix[newPos] != Void && cbMatrix[newPos].color != p.color)
        EatPieceIn(newPos);
    cbMatrix[newPos] = p;
    if(oldPos != newPos)
    {
        p.moved++;

        var oldPosXY = p.CalcXYPosition(oldPos, corner, dimension);
        var newPosXY = p.CalcXYPosition(newPos, corner, dimension);
        anim.Add(p, 0.0, p.obj.GetPosition(), newPosXY, 30);

        SetEnPassant(p, oldPos, newPos);

        OutputLN(latestMove);

        if(p.type == CP_KING)
            Castle(p, oldPos);

        latestMove = {totalMovesCounter, turn, GenerateMovetext(oldPos, newPos), p};
        PrintMoveString(turn, p.type, oldPos, newPos);

        if(end)
            EndTurn(); //TODO:WARNING!!! Promotion only at the end of animation, fix it!
    }
}

function ChessBoard::SetEnPassant(p, oldPos, newPos)
{
    enPassant = Void;

    if(p.type == CP_PAWN)
    {
        if(p.color == CP_W && oldPos < 16 && newPos > 23)
            enPassant = {p, Conv64ToAH(oldPos + 8), oldPos + 8};
        else if(p.color == CP_B && oldPos > 47 && newPos < 40)
            enPassant = {p, Conv64ToAH(oldPos - 8), oldPos - 8};
    }
}

function ChessBoard::Conv64ToAH(pos)
{
    var lett = lower(letters[pos%8]);
    OutputLN(lett);
    var rank = Int(pos/8)+1;

    return Sprintf("%s%d", lett, rank);
}

function ChessBoard::EndTurn()
{
    if(turn == CP_B)
    {
        totalMovesCounter++;
        turn = CP_W;
        lb.Add("Waiting for White to move...");
    }
    else
    {
        turn = CP_B;
        lb.Add("Waiting for Black to move...");
    }
}

function ChessBoard::IsCheck(color, checkPos)
{
    var enemies, kingPosition;
    var attackedSquares;
    if(color == CP_W)
    {
        enemies = bPieces;
        kingPosition = wPieces[7].position;
    }
    else
    {
        enemies = wPieces;
        kingPosition = bPieces[7].position;
    }

    for(var i = 0; i < 16; i++)
    {
        var e = enemies[i];

        if(e.type == CP_KING) continue; //the king can't check

        if (e.position != -1)
        {
            attackedSquares = LegalMoves(e, true);
            if(attackedSquares[kingPosition] != Void)
                {
                    //OutputLN("Check by ", e.type, " in ", kingPosition);
                    checkPos = kingPosition;
                    lb.Add("CHECK!");
                    return true;
                }
        }
    }
    return false;
}

function ChessBoard::IsCheckMate(color)
{
    var tmp = null;
    if(!IsCheck(color, &tmp))
        return false;

    var friends = color == CP_W ? wPieces : bPieces;
    var lglMoves;

    for(var i = 0; i < 16; i++)
    {
        var f = friends[i];

        if (f.position != -1)
        {
            lglMoves = LegalMoves(f, false);
            for(var j = 0; j < 64; j++)
            {
                if(lglMoves[j] != Void && j != f.position)
                    return false;
            }
        }
    }
    return true;
}

function ChessBoard::IsCheckInNewPos(piece, newPos)
{
    var oldPos = piece.position;
    var oldM = cbMatrix[newPos];
    var check = false;
    //change the chessboard
    cbMatrix[oldPos] = Void;
    cbMatrix[newPos] = piece;
    piece.position = newPos;
    if(oldM != Void)
        oldM.position = -1;

    var tmp;
    check = IsCheck(piece.color, &tmp);

    //restore chessboard
    if(oldM != Void)
        oldM.position = newPos;
    piece.position = oldPos;
    cbMatrix[newPos] = oldM;
    cbMatrix[oldPos] = piece;
    return check;
}


/***********************+
K: white, king side, O-O
Q: white, queem sode, O-O-O
**************************/
function ChessBoard::CastlingStatus()
{
    //           K    Q     k     q
    var result = {true, true, true, true};

    var wKing = wPieces[7];
    var bKing = bPieces[7];
    var wTQ = wPieces[0];
    var wTK = wPieces[1];
    var bTQ = bPieces[0];
    var bTK = bPieces[1];

    //1.The king and the chosen rook are on the player's first rank.
    //2.Neither the king nor the chosen rook has previously moved.
    result[0] = !wKing.IsMoved() && !wTK.IsMoved();
    result[1] = !wKing.IsMoved() && !wTQ.IsMoved();
    result[2] = !bKing.IsMoved() && !bTK.IsMoved();
    result[3] = !bKing.IsMoved() && !bTQ.IsMoved();

    //3.There are no pieces between the king and the chosen rook.
    result[0] = result[0] && cbMatrix[5] == Void && cbMatrix[6] == Void;
    result[1] = result[1] && cbMatrix[1] == Void && cbMatrix[2] == Void && cbMatrix[3] == Void;
    result[2] = result[2] && cbMatrix[61] == Void && cbMatrix[62] == Void;
    result[3] = result[3] && cbMatrix[57] == Void && cbMatrix[58] == Void && cbMatrix[59] == Void;

    //4.The king is not currently in check.
    var tmp;
    result[0] = result[0] && !IsCheck(wKing.color, &tmp);
    result[1] = result[1] && !IsCheck(wKing.color, &tmp);
    result[2] = result[2] && !IsCheck(bKing.color, &tmp);
    result[3] = result[3] && !IsCheck(bKing.color, &tmp);

    //5.The king does not pass through a square that is attacked by an enemy piece.
    //6.The king does not end up in check. (True of any legal move.)
    result[0] = result[0] && !IsCheckInNewPos(wKing, 5) && !IsCheckInNewPos(wKing, 6);
    result[1] = result[1] && !IsCheckInNewPos(wKing, 2) && !IsCheckInNewPos(wKing, 3);
    result[2] = result[2] && !IsCheckInNewPos(bKing, 61) && !IsCheckInNewPos(bKing, 62);
    result[3] = result[3] && !IsCheckInNewPos(bKing, 58) && !IsCheckInNewPos(bKing, 59);

    return result;
}

function ChessBoard::Castle(king, oldPos)
{
    if(king.type != CP_KING)
        return false;

    var diff = oldPos - king.position;
    var pieces = king.color == CP_W ? wPieces : bPieces;
    if(abs(diff) == 2)
    {
        if(diff > 0)
        {
            AddForUndo({pieces[0], "C", pieces[0].position});
            MovePieceToPos(pieces[0], king.position + 1, false);
        }
        else
        {
            AddForUndo({pieces[1], "C", pieces[1].position});
            MovePieceToPos(pieces[1], king.position - 1, false);
        }
        lb.Add("Castling");
        return true;
    }
    else return false;
}

//m = {piece, movetype(Eated, Castling, Promotion, Regular), oldPos}
function ChessBoard::AddForUndo(m)
{
    undoList[undoListHead] = m;
    undoListHead = (undoListHead + 1) % undoListSize;
}

function ChessBoard::Undo() //TODO: what if not enough history? (Only in case of multiple undo)
{
    var moves = 0;
    undoListHead = (undoListHead + undoListSize - 1) % undoListSize;
    while(moves < 2 && undoList[undoListHead] != Void)
    {
        var p = undoList[undoListHead][0];
        var oldPos = p.position;
        if(oldPos != -1)
            cbMatrix[p.position] = Void;
        var newPos =  undoList[undoListHead][2];
        p.position = newPos;
        cbMatrix[newPos] = p;
        p.moved -= 1;

        var newPosXY = p.CalcXYPosition(newPos, corner, dimension);
        anim.Add(p, 0.0, p.obj.GetPosition(), newPosXY, 30);

        var mt =  undoList[undoListHead][1];
        if(mt == "C")
            moves += 0.5;
        else if(mt == "R")
            moves += 1;

        undoList[undoListHead] = Void;
        undoListHead = (undoListHead + undoListSize - 1) % undoListSize;
    }

    if(moves >= 2)
    {
        totalMovesCounter--;
        return true;
    }
    else
        return false;
}

#endif