void LineCapture(PieceBoard board, int x, int y, int dX, int dY)
{
int sX = x;
int sY = y;
int i = 0;
while (true)
{
sX += dX;
sY += dY;
if (!board.InBounds(sX, sY) || EmptySpace(board, sX, sY))
{
return;
}
else if (FriendSpace(board, sX, sY))
{
break;
}
i++;
}
sX = x; sY = y;
for (int j = 0; j < i; j++)
{
sX += dX;
sY += dY;
CapturePiece(board, sX, sY);
}
}
public override bool[,] possibleMov()
{
bool[,] mat = new bool[PieceBoard.Lines, PieceBoard.Column];
Position position = new Position(PiecePos.Line, PiecePos.Column);
int acum = position.Line + 1;
int dec = position.Line - 1;
bool isMoveAcum = true;
bool isMoveDec = true;
for (int j = position.Column - 1; j >= 0; j--)
{
if (PieceBoard.isPosition(new Position(acum, j)) && canMov(new Position(acum, j)) && isMoveAcum)
{
mat[acum, j] = true;
}
else
{
isMoveAcum = false;
}
acum++;
if (PieceBoard.isPosition(new Position(dec, j)) && canMov(new Position(dec, j)) && isMoveDec)
{
mat[dec, j] = true;
}
else
{
isMoveDec = false;
}
dec--;
}
isMoveAcum = true;
isMoveDec = true;
position = new Position(PiecePos.Line, PiecePos.Column);
dec = position.Line - 1;
acum = position.Line + 1;
for (int j = position.Column + 1; j < PieceBoard.Column; j++)
{
if (PieceBoard.isPosition(new Position(acum, j)) && canMov(new Position(acum, j)) && isMoveAcum)
{
mat[acum, j] = true;
}
else
{
isMoveAcum = false;
}
acum++;
if (PieceBoard.isPosition(new Position(dec, j)) && canMov(new Position(dec, j)) && isMoveDec)
{
mat[dec, j] = true;
}
else
{
isMoveDec = false;
}
dec--;
}
return(mat);
}
public override bool[,] PossibleMoves2(PieceBoard board, int x, int y)
{
bool[,] possible = PossibleMoves3(board, x, y);
ChessGame chess = board as ChessGame;
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (possible[i, j])
{
MobilePiece overwritePiece = board.pieces[i, j];
board.pieces[i, j] = board.pieces[x, y];
board.pieces[x, y] = null;
Point kingPos = chess.GetKingPos(white);
bool check = chess.InCheck(kingPos.X, kingPos.Y, white);
//Console.WriteLine(check);
board.pieces[x, y] = board.pieces[i, j];
board.pieces[i, j] = overwritePiece;
if (check)
{
possible[i, j] = false;
}
}
}
}
return(possible);
}
protected override void AfterMove(PieceBoard board, int x1, int y1, int x2, int y2)
{
LineCapture(board, x2, y2, 1, 0);
LineCapture(board, x2, y2, -1, 0);
LineCapture(board, x2, y2, 0, 1);
LineCapture(board, x2, y2, 0, -1);
// Corner captures
void CheckCorner(int j, int k)
{
int nJ = (j == 0) ? 1 : 7;
int nK = (k == 0) ? 1 : 7;
if (board.ComparePieceColours(board.pieces[nJ, k], board.pieces[j, nK]) &&
board.pieces[j, k] != null && board.pieces[j, k].white != board.pieces[nJ, k].white)
{
CapturePiece(board, j, k);
}
}
CheckCorner(0, 0);
CheckCorner(8, 0);
CheckCorner(0, 8);
CheckCorner(8, 8);
}
internal bool[,] PossibleCaptures(PieceBoard board, int x, int y, out bool any)
{
bool[,] possible = new bool[8, 8];
bool captureMove(int x1, int y1, int x2, int y2)
{
if (EnemySpace(board, x1, y1) && EmptySpace(board, x2, y2))
{
possible[x2, y2] = true;
return(true);
}
return(false);
}
//canCapture = false;
any = false;
if (white || king)
{
if (captureMove(x - 1, y - 1, x - 2, y - 2) | captureMove(x + 1, y - 1, x + 2, y - 2))
{
any = true;
}
}
if (!white || king)
{
if (captureMove(x - 1, y + 1, x - 2, y + 2) | captureMove(x + 1, y + 1, x + 2, y + 2))
{
any = true;
}
}
return(possible);
}
public bool canMoveToPosition(Position destiny)
{
if (!PieceBoard.isPosition(destiny))
{
throw new BoardException("please insert a valid position!");
}
return(possibleMov()[destiny.Line, destiny.Column]);
}
public override bool[,] PossibleMoves3(PieceBoard board, int x, int y)
{
bool[,] possible = new bool[8, 8];
if (PossibleSpace(board, x + 1, y))
{
possible[x + 1, y] = true;
}
if (PossibleSpace(board, x + 1, y + 1))
{
possible[x + 1, y + 1] = true;
}
if (PossibleSpace(board, x + 1, y - 1))
{
possible[x + 1, y - 1] = true;
}
if (PossibleSpace(board, x - 1, y))
{
possible[x - 1, y] = true;
}
if (PossibleSpace(board, x - 1, y + 1))
{
possible[x - 1, y + 1] = true;
}
if (PossibleSpace(board, x - 1, y - 1))
{
possible[x - 1, y - 1] = true;
}
if (PossibleSpace(board, x, y + 1))
{
possible[x, y + 1] = true;
}
if (PossibleSpace(board, x, y - 1))
{
possible[x, y - 1] = true;
}
if (!moved)
{
ChessGame chess = board as ChessGame;
if (board.pieces[5, y] == null && board.pieces[6, y] == null &&
board.pieces[7, y] is Rook r1 && !r1.moved && r1.white == white &&
!chess.InCheck(5, y, white) && !chess.InCheck(6, y, white))
{
possible[6, y] = true;
}
if (board.pieces[3, y] == null && board.pieces[2, y] == null && board.pieces[1, y] == null &&
board.pieces[0, y] is Rook r2 && !r2.moved && r2.white == white &&
!chess.InCheck(3, y, white) && !chess.InCheck(2, y, white))
{
possible[2, y] = true;
}
}
return(possible);
}
public override bool[,] PossibleMoves()
{
bool[,] matrix = new bool[PieceBoard.Rows, PieceBoard.Columns];
Position p = new Position(0, 0);
//up
p.DefineValues(Position.Row - 1, Position.Column);
while (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
if (PieceBoard.piece(p) != null && PieceBoard.piece(p).Color != Color)
{
break;
}
p.Row = p.Row - 1;
}
//down
p.DefineValues(Position.Row + 1, Position.Column);
while (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
if (PieceBoard.piece(p) != null && PieceBoard.piece(p).Color != Color)
{
break;
}
p.Row = p.Row + 1;
}
//right
p.DefineValues(Position.Row, Position.Column + 1);
while (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
if (PieceBoard.piece(p) != null && PieceBoard.piece(p).Color != Color)
{
break;
}
p.Column = p.Column + 1;
}
//left
p.DefineValues(Position.Row, Position.Column - 1);
while (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
if (PieceBoard.piece(p) != null && PieceBoard.piece(p).Color != Color)
{
break;
}
p.Column = p.Column - 1;
}
return(matrix);
}
public override bool[,] PossibleMoves3(PieceBoard board, int x, int y)
{
bool[,] possible = new bool[8, 8];
DirectionalPossible(ref possible, board, x, y, 1, 1);
DirectionalPossible(ref possible, board, x, y, -1, 1);
DirectionalPossible(ref possible, board, x, y, 1, -1);
DirectionalPossible(ref possible, board, x, y, -1, -1);
return(possible);
}
public override bool[,] possibleMov()
{
bool[,] mat = new bool[PieceBoard.Lines, PieceBoard.Column];
Position position = new Position(PiecePos.Line - 1, PiecePos.Column);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Line--;
}
position = new Position(PiecePos.Line + 1, PiecePos.Column);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Line++;
}
position = new Position(PiecePos.Line, PiecePos.Column - 1);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Column--;
}
position = new Position(PiecePos.Line, PiecePos.Column + 1);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Column++;
}
return(mat);
}
protected override bool CancelMove(PieceBoard board, int x1, int y1, int x2, int y2, Action action = null)
{
if (x2 == x1 + 2)
{
(board.pieces[7, y1] as Rook).Move(board, 7, y1, 5, y1);
}
else if (x2 == x1 - 2)
{
(board.pieces[0, y1] as Rook).Move(board, 0, y1, 3, y1);
}
return(false);
}
public override bool[,] possibleMov()
{
bool[,] mat = new bool [PieceBoard.Lines, PieceBoard.Column];
//if (PieceBoard.isPosition(pos) && canMov(pos))
Position pos = new Position(PiecePos.Line + 1, PiecePos.Column + 2);
if (PieceBoard.isPosition(pos) && canMov(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos = new Position(PiecePos.Line + 2, PiecePos.Column + 1);
if (PieceBoard.isPosition(pos) && canMov(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos = new Position(PiecePos.Line - 1, PiecePos.Column + 2);
if (PieceBoard.isPosition(pos) && canMov(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos = new Position(PiecePos.Line + 1, PiecePos.Column - 2);
if (PieceBoard.isPosition(pos) && canMov(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos = new Position(PiecePos.Line - 1, PiecePos.Column - 2);
if (PieceBoard.isPosition(pos) && canMov(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos = new Position(PiecePos.Line - 2, PiecePos.Column - 1);
if (PieceBoard.isPosition(pos) && canMov(pos))
{
mat[pos.Line, pos.Column] = true;
}
pos = new Position(PiecePos.Line - 2, PiecePos.Column + 1);
if (PieceBoard.isPosition(pos) && canMov(pos))
{
mat[pos.Line, pos.Column] = true;
}
return(mat);
}
public override bool[,] PossibleMoves3(PieceBoard board, int x, int y)
{
bool[,] possible = new bool[8, 8];
if (white)
{
if (EmptySpace(board, x, y - 1))
{
possible[x, y - 1] = true;
if (y == 6 && EmptySpace(board, x, y - 2))
{
possible[x, y - 2] = true;
}
}
if (EnemySpace(board, x + 1, y - 1))
{
possible[x + 1, y - 1] = true;
}
if (EnemySpace(board, x - 1, y - 1))
{
possible[x - 1, y - 1] = true;
}
}
else
{
if (EmptySpace(board, x, y + 1))
{
possible[x, y + 1] = true;
if (y == 1 && EmptySpace(board, x, y + 2))
{
possible[x, y + 2] = true;
}
}
if (EnemySpace(board, x + 1, y + 1))
{
possible[x + 1, y + 1] = true;
}
if (EnemySpace(board, x - 1, y + 1))
{
possible[x - 1, y + 1] = true;
}
}
return(possible);
}
public override bool[,] possibleMov()
{
Position position = new Position(PiecePos.Line, PiecePos.Column);
bool[,] mat = new bool[PieceBoard.Lines, PieceBoard.Column];
for (int i = position.Line - 1; i <= position.Line + 1; i++)
{
for (int j = position.Column - 1; j <= position.Column + 1; j++)
{
if (PieceBoard.isPosition(new Position(i, j)) && canMov(new Position(i, j)))
{
mat[i, j] = true;
}
else if (PieceBoard.isPosition(new Position(i, j)) && !canMov(new Position(i, j)))
{
mat[i, j] = false;
}
}
}
//#expessial movies
if (QteMoviment == 0 && !KingMatch.adversaryCheck)
{
Position posT = new Position(PiecePos.Line, PiecePos.Column - 3);
Position posT2 = new Position(PiecePos.Line, PiecePos.Column + 4);
if (isTowerRoque(posT))
{
Position p1 = new Position(PiecePos.Line, PiecePos.Column - 1);
Position p2 = new Position(PiecePos.Line, PiecePos.Column - 2);
if (PieceBoard.GetPiece(p1) == null && PieceBoard.GetPiece(p2) == null)
{
mat[PiecePos.Line, PiecePos.Column - 2] = true;
}
}
if (isTowerRoque(posT2))
{
Position p1 = new Position(PiecePos.Line, PiecePos.Column + 1);
Position p2 = new Position(PiecePos.Line, PiecePos.Column + 2);
Position p3 = new Position(PiecePos.Line, PiecePos.Column + 3);
if (PieceBoard.GetPiece(p1) == null && PieceBoard.GetPiece(p2) == null && PieceBoard.GetPiece(p3) == null)
{
mat[PiecePos.Line, PiecePos.Column + 2] = true;
}
}
}
return(mat);
}
void DirectionalPossible(ref bool[,] possible, PieceBoard board, int x, int y, int dX, int dY)
{
int sX = x;
int sY = y;
while (true)
{
if (!EmptySpace(board, sX + dX, sY + dY))
{
break;
}
sX += dX;
sY += dY;
possible[sX, sY] = true;
}
}
public override void BeforeMove(PieceBoard board, int x1, int y1, int x2, int y2)
{
if (turnInto == 0)
{
base.BeforeMove(board, x1, y1, x2, y2);
}
else
{
SendGameMessage(msg =>
{
msg.Write(x1);
msg.Write(y1);
msg.Write(x2);
msg.Write(y2);
msg.Write(turnInto);
});
}
}
protected override void AfterMove(PieceBoard board, int x1, int y1, int x2, int y2)
{
if (Math.Abs(x2 - x1) == 2)
{
board.pieces[(x1 + x2) / 2, (y1 + y2) / 2] = null;
(board as DraughtsGame).capturingPiece = new Point(x2, y2);
}
if (!king && (y2 == 0 || y2 == 7))
{
king = true;
MobilePiece piece = this;
board.pieces[x2, y2] = null;
board.animations.Add(new SpriteAnim(white ? whitePieces.flip : blackPieces.flip,
new Vector2(x2, y2) + Vector2.One / 2,
() => board.pieces[x2, y2] = piece));
}
}
public override bool[,] PossibleMoves3(PieceBoard board, int x, int y)
{
bool[,] possible = new bool[8, 8];
if (PossibleSpace(board, x + 2, y + 1))
{
possible[x + 2, y + 1] = true;
}
if (PossibleSpace(board, x + 2, y - 1))
{
possible[x + 2, y - 1] = true;
}
if (PossibleSpace(board, x + 1, y - 2))
{
possible[x + 1, y - 2] = true;
}
if (PossibleSpace(board, x - 1, y - 2))
{
possible[x - 1, y - 2] = true;
}
if (PossibleSpace(board, x - 2, y + 1))
{
possible[x - 2, y + 1] = true;
}
if (PossibleSpace(board, x - 2, y - 1))
{
possible[x - 2, y - 1] = true;
}
if (PossibleSpace(board, x + 1, y + 2))
{
possible[x + 1, y + 2] = true;
}
if (PossibleSpace(board, x - 1, y + 2))
{
possible[x - 1, y + 2] = true;
}
return(possible);
}
public override bool[,] PossibleMoves2(PieceBoard board, int x, int y)
{
Point capturing = (board as DraughtsGame).capturingPiece;
if (capturing.X != -1 && (capturing.X != x || capturing.Y != y))
{
return(new bool[8, 8]);
}
bool[,] possible = PossibleMoves3(board, x, y, out bool canCapture);
if (canCapture)
{
return(possible);
}
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (x == i && y == j)
{
continue;
}
if (board.pieces[i, j] != null && board.pieces[i, j].white == white)
{
(board.pieces[i, j] as Draught).PossibleCaptures(board, i, j, out bool any);
if (any)
{
return(new bool[8, 8]);
}
}
}
}
return(possible);
}
protected override bool CancelMove(PieceBoard board, int x1, int y1, int x2, int y2, Action action = null)
{
if (turnInto == 0 && (y2 == 0 || y2 == 7))
{
OptionsOverlay splash = new OptionsOverlay("What will your pawn turn into?", new string[] { "Knight", "Bishop", "Rook", "Queen" })
{
action = (string s) =>
{
switch (s)
{
case "Knight":
turnInto = 1;
break;
case "Bishop":
turnInto = 2;
break;
case "Rook":
turnInto = 3;
break;
case "Queen":
turnInto = 4;
break;
}
Move(board, x1, y1, x2, y2, action);
}
};
board.overlay = splash;
return(true);
}
else
{
return(false);
}
}
protected override void AfterMove(PieceBoard board, int x1, int y1, int x2, int y2)
{
if (y2 == 0 || y2 == 7)
{
switch (turnInto)
{
case 1:
board.pieces[x2, y2] = new Knight(white);
break;
case 2:
board.pieces[x2, y2] = new Bishop(white);
break;
case 3:
board.pieces[x2, y2] = new Rook(white);
break;
case 4:
board.pieces[x2, y2] = new Queen(white);
break;
}
}
}
protected bool[,] PossibleMoves3(PieceBoard board, int x, int y, out bool canCapture)
{
bool[,] possible = PossibleCaptures(board, x, y, out canCapture);
if (white || king)
{
if (!canCapture)
{
if (EmptySpace(board, x - 1, y - 1))
{
possible[x - 1, y - 1] = true;
}
if (EmptySpace(board, x + 1, y - 1))
{
possible[x + 1, y - 1] = true;
}
}
}
if (!white || king)
{
if (!canCapture)
{
if (EmptySpace(board, x - 1, y + 1))
{
possible[x - 1, y + 1] = true;
}
if (EmptySpace(board, x + 1, y + 1))
{
possible[x + 1, y + 1] = true;
}
}
}
return(possible);
}
private bool isTowerRoque(Position pos)
{
Piece p = PieceBoard.GetPiece(pos);
return(p != null && p is Tower && p.PieceColor == this.PieceColor && p.QteMoviment == 0);
}
public abstract bool[,] PossibleMoves3(PieceBoard board, int x, int y);
public override bool[,] possibleMov()
{
bool[,] mat = new bool[PieceBoard.Lines, PieceBoard.Column];
ChessMatch match = new ChessMatch();
if (PieceColor == Color.white)
{
int line = PiecePos.Line;
int col = PiecePos.Column + 1;
int revcol = PiecePos.Column - 1;
if (PiecePos.Line == 6)
{
while (line > PiecePos.Line - 3)
{
if (PieceBoard.isPosition(new Position(PiecePos.Line - 1, col)) && canCapture(new Position(PiecePos.Line - 1, col)))
{
mat[PiecePos.Line - 1, col] = true;
}
if (PieceBoard.isPosition(new Position(PiecePos.Line - 1, revcol)) && canCapture(new Position(PiecePos.Line - 1, revcol)))
{
mat[PiecePos.Line - 1, revcol] = true;
}
if (PieceBoard.isPosition(new Position(line, PiecePos.Column)) && canMov(new Position(line, PiecePos.Column)))
{
mat[line, PiecePos.Column] = true;
}
line--;
}
}
else
{
if (PieceBoard.isPosition(new Position(line - 1, col)) && canCapture(new Position(line - 1, col)))
{
mat[line - 1, col] = true;
}
if (PieceBoard.isPosition(new Position(line - 1, revcol)) && canCapture(new Position(line - 1, revcol)))
{
mat[line - 1, revcol] = true;
}
if (PieceBoard.isPosition(new Position(line - 1, PiecePos.Column)) && canMov(new Position(line - 1, PiecePos.Column)))
{
mat[line - 1, PiecePos.Column] = true;
}
}
//en passant
if (PiecePos.Line == 3)
{
Position left = new Position(PiecePos.Line, PiecePos.Column - 1);
if (PieceBoard.isPieceOnPos(left) && isEnemy(left) && PieceBoard.GetPiece(left) == _match._vulnerableEnPassant)
{
mat[left.Line - 1, left.Column] = true;
}
Position right = new Position(PiecePos.Line, PiecePos.Column + 1);
if (PieceBoard.isPieceOnPos(right) && isEnemy(right) && PieceBoard.GetPiece(right) == _match._vulnerableEnPassant)
{
mat[right.Line - 1, right.Column] = true;
}
}
}
else
{
int line = PiecePos.Line;
int col = PiecePos.Column + 1;
int revcol = PiecePos.Column - 1;
if (PiecePos.Line == 1)
{
while (line < PiecePos.Line + 3)
{
if (PieceBoard.isPosition(new Position(PiecePos.Line + 1, col)) && canCapture(new Position(PiecePos.Line + 1, col)))
{
mat[PiecePos.Line + 1, col] = true;
}
if (PieceBoard.isPosition(new Position(PiecePos.Line + 1, revcol)) && canCapture(new Position(PiecePos.Line + 1, revcol)))
{
mat[PiecePos.Line + 1, revcol] = true;
}
if (PieceBoard.isPosition(new Position(line, PiecePos.Column)) && canMov(new Position(line, PiecePos.Column)))
{
mat[line, PiecePos.Column] = true;
}
line++;
}
}
else
{
if (PieceBoard.isPosition(new Position(line + 1, col)) && canCapture(new Position(line + 1, col)))
{
mat[line + 1, col] = true;
}
if (PieceBoard.isPosition(new Position(line + 1, revcol)) && canCapture(new Position(line + 1, revcol)))
{
mat[line + 1, revcol] = true;
}
if (PieceBoard.isPosition(new Position(line + 1, PiecePos.Column)) && canMov(new Position(line + 1, PiecePos.Column)))
{
mat[line + 1, PiecePos.Column] = true;
}
}
//en passant
if (PiecePos.Line == 4)
{
Position left = new Position(PiecePos.Line, PiecePos.Column - 1);
if (PieceBoard.isPieceOnPos(left) && isEnemy(left) && PieceBoard.GetPiece(left) == _match._vulnerableEnPassant)
{
mat[left.Line + 1, left.Column] = true;
}
Position right = new Position(PiecePos.Line, PiecePos.Column + 1);
if (PieceBoard.isPieceOnPos(right) && isEnemy(right) && PieceBoard.GetPiece(right) == _match._vulnerableEnPassant)
{
mat[right.Line + 1, right.Column] = true;
}
}
}
return(mat);
}
public override bool[,] possibleMov()
{
bool[,] mat = new bool[PieceBoard.Lines, PieceBoard.Column];
Position position = new Position(PiecePos.Line, PiecePos.Column);
int acum = position.Line + 1;
int dec = position.Line - 1;
bool isMoveAcum = true;
bool isMoveDec = true;
for (int j = position.Column - 1; j >= 0; j--)
{
if (PieceBoard.isPosition(new Position(acum, j)) && canMov(new Position(acum, j)) && isMoveAcum)
{
mat[acum, j] = true;
}
else
{
isMoveAcum = false;
}
acum++;
if (PieceBoard.isPosition(new Position(dec, j)) && canMov(new Position(dec, j)) && isMoveDec)
{
mat[dec, j] = true;
}
else
{
isMoveDec = false;
}
dec--;
}
isMoveAcum = true;
isMoveDec = true;
position = new Position(PiecePos.Line, PiecePos.Column);
dec = position.Line - 1;
acum = position.Line + 1;
for (int j = position.Column + 1; j < PieceBoard.Column; j++)
{
if (PieceBoard.isPosition(new Position(acum, j)) && canMov(new Position(acum, j)) && isMoveAcum)
{
mat[acum, j] = true;
}
else
{
isMoveAcum = false;
}
acum++;
if (PieceBoard.isPosition(new Position(dec, j)) && canMov(new Position(dec, j)) && isMoveDec)
{
mat[dec, j] = true;
}
else
{
isMoveDec = false;
}
dec--;
}
isMoveAcum = true;
isMoveDec = true;
position = new Position(PiecePos.Line - 1, PiecePos.Column);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Line--;
}
position = new Position(PiecePos.Line + 1, PiecePos.Column);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Line++;
}
position = new Position(PiecePos.Line, PiecePos.Column - 1);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Column--;
}
position = new Position(PiecePos.Line, PiecePos.Column + 1);
while (PieceBoard.isPosition(position) && canMov(position))
{
mat[position.Line, position.Column] = true;
if (PieceBoard.GetPiece(position) != null && PieceBoard.GetPiece(position).PieceColor != PieceColor)
{
break;
}
position.Column++;
}
return(mat);
}
private bool CanMove(Position position)
{
Piece piece = PieceBoard.piece(position);
return(piece == null || piece.Color != Color);
}
public override bool[,] PossibleMoves()
{
bool[,] matrix = new bool[PieceBoard.Rows, PieceBoard.Columns];
Position p = new Position(0, 0);
//up
p.DefineValues(Position.Row - 1, Position.Column);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
//up&right
p.DefineValues(Position.Row - 1, Position.Column + 1);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
//right
p.DefineValues(Position.Row, Position.Column + 1);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
//down&right
p.DefineValues(Position.Row + 1, Position.Column + 1);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
//down
p.DefineValues(Position.Row + 1, Position.Column);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
//down&left
p.DefineValues(Position.Row + 1, Position.Column - 1);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
//left
p.DefineValues(Position.Row, Position.Column - 1);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
//up&left
p.DefineValues(Position.Row - 1, Position.Column - 1);
if (PieceBoard.ValidPosition(p) && CanMove(p))
{
matrix[p.Row, p.Column] = true;
}
return(matrix);
}
void CapturePiece(PieceBoard board, int x, int y)
{
board.animations.Add(new ZoomAnim(board.pieces[x, y].GetTexture, new Vector2(x, y), null, Vector2.One, Vector2.Zero));
board.pieces[x, y] = null;
}
private bool canMov(Position p)
{
Piece aux = PieceBoard.GetPiece(p);
return(aux == null || aux.PieceColor != PieceColor);
}
