public void SetFigureOnBoard(BoardPosition pos, IChessItemModel chessItem)
{
FiguresPlacement[pos.horizontal, pos.vertical] = chessItem;
if (!chessItem.IsNullObject)
{
FiguresPlacement[pos.horizontal, pos.vertical].SetPosition(pos);
}
}
public virtual void MoveBack()
{
if (AllMoves.Count == 0)
{
return;
}
var move = AllMoves.Last();
PreviousPlayer = Players[currentPlayerIndex];
currentPlayerIndex--;
if (currentPlayerIndex < 0)
{
currentPlayerIndex = Players.Count - 1;
}
LastPlayerAction = PlayerAction.Nothing;
PreviousSelectedPosition = new BoardPosition(move.to_x, move.to_y);
CurrentSelectedPosition = new BoardPosition(move.from_x, move.from_y, true);
BoardKit.SetFigureOnBoard(CurrentSelectedPosition, BoardKit.GetFigureFromBoard(PreviousSelectedPosition));
BoardKit.GetFigureFromBoard(CurrentSelectedPosition).Steps -= 2;
var chessFactory = new ChessItemModelFactory();
IChessItemModel killed_chess;
if (move.killed_isnull)
{
killed_chess = new NullChessItemModel();
}
else
{
killed_chess = chessFactory.CreateChessItemModel(new BoardPosition(move.killed_x, move.killed_y), move.killed_type, move.killed_steps, move.killed_side);
}
BoardKit.FiguresPlacement[PreviousSelectedPosition.horizontal, PreviousSelectedPosition.vertical] = killed_chess;
IChessItemModel recoveryItem = null;
if (!move.killed_isnull)
{
recoveryItem = ChessEngineFunctions.GetKilledChessItemFromMove(move, chessGameType);
BoardKit.FiguresPlacement[move.killed_x, move.killed_y] = recoveryItem;
}
AllMoves.RemoveAt(AllMoves.Count - 1);
LastPlayerAction = PlayerAction.Move;
CurrentPlayer = Players[currentPlayerIndex];
OnChanged(this, new ChessSideArgs(move.side));
if (!move.killed_isnull)
{
OnFigureRecovery(this, new ChessItemArgs(recoveryItem));
}
}
public FigureMove(BoardPosition from, BoardPosition to, IChessItemModel killed_item, ChessSide side)
{
from_x = from.horizontal;
from_y = from.vertical;
to_x = to.horizontal;
to_y = to.vertical;
killed_side = killed_item.Side;
killed_type = killed_item.Type;
killed_steps = (short)killed_item.Steps;
killed_x = killed_item.Pos.horizontal;
killed_y = killed_item.Pos.vertical;
killed_isnull = killed_item.IsNullObject;
this.side = side;
}
public static string ConvertToShortFEN(IChessItemModel[,] ch_on_b)
{
//Figure placement
StringBuilder sb = new StringBuilder();
int empty_count = 0;
for (int i = ch_on_b.GetLength(1) - 1; i >= 0; i--)
{
for (int j = 0; j < ch_on_b.GetLength(0); j++)
{
IChessItemModel ch_item = ch_on_b[j, i];
if (!ch_item.IsNullObject)
{
if (empty_count > 0)
{
sb.Append(empty_count);
empty_count = 0;
}
var s = GetFigureLetter(false, ch_item.Side, ch_item.Type);
sb.Append(s);
}
else
{
empty_count++;
}
}
if (empty_count > 0)
{
sb.Append(empty_count);
empty_count = 0;
}
if (i != 0)
{
sb.Append('/');
}
}
return(sb.ToString());
}
public virtual bool TryMoveChessItem(ChessSide curr_side, BoardPosition from, BoardPosition to, out BoardPosition captureOnTheIsle, out IChessItemModel killed_model)
{
killed_model = new NullChessItemModel();
captureOnTheIsle = BoardPosition.None;
//If figure wasn't chosen before or new selected figure is the same
if (GetFigureFromBoard(from).IsNullObject || from == to)
{
captureOnTheIsle = BoardPosition.None;
return(false);
}
else
{
//If selected board item has figure
if (!GetFigureFromBoard(to).IsNullObject)
{
//If sides of previous selected figure and current are same
if (GetFigureFromBoard(to).Side == curr_side)
{
captureOnTheIsle = BoardPosition.None;
return(castlingPossibility &&
GetFigureFromBoard(to).Type == (byte)ClassicChessItemType.king && GetFigureFromBoard(from).Type == (byte)ClassicChessItemType.rook ||
GetFigureFromBoard(to).Type == (byte)ClassicChessItemType.rook && GetFigureFromBoard(from).Type == (byte)ClassicChessItemType.king);
}
//If side of previous selected and current are different
else
{
captureOnTheIsle = BoardPosition.None;
//MoveChessItem(from, to, false);
var temp_chess_item = MoveChessItemPredictForward(from, to);
if (CheckForCheck(curr_side))
{
killed_model = new NullChessItemModel();
MoveChessItemPredictBackward(temp_chess_item, from, to);
return(false);
}
else
{
MoveChessItemPredictBackward(temp_chess_item, from, to);
killed_model = GetFigureFromBoard(to);
MoveChessItem(from, to);
return(true);
}
}
}
//If selected board item doesn't have figure
else
{
//If it's pawn, check for capture on the isle
if (GetFigureFromBoard(from).Type == (byte)ClassicChessItemType.pawn)
{
if (System.Math.Abs(from.vertical - to.vertical) == 2)
{
byte hor = 0;
byte vert = 0;
switch (GetFigureFromBoard(from).Side)
{
case ChessSide.white:
hor = from.horizontal;
vert = (byte)(from.vertical + 1);
break;
case ChessSide.black:
hor = from.horizontal;
vert = (byte)(from.vertical - 1);
break;
case ChessSide.red:
hor = (byte)(from.horizontal + 1);
vert = from.vertical;
break;
case ChessSide.green:
hor = (byte)(from.horizontal - 1);
vert = from.vertical;
break;
default:
break;
}
captureOnTheIsle = new BoardPosition(hor, vert);
}
}
var temp_chess_item = MoveChessItemPredictForward(from, to);
if (CheckForCheck(curr_side))
{
MoveChessItemPredictBackward(temp_chess_item, from, to);
return(false);
}
else
{
MoveChessItemPredictBackward(temp_chess_item, from, to);
MoveChessItem(from, to);
var side = GetFigureFromBoard(to).Side;
bool isMomentToMakeQueenFromPawn = false;
if (side == ChessSide.white && to.vertical == Max_Y - 1)
{
isMomentToMakeQueenFromPawn = true;
}
else if (side == ChessSide.black && to.vertical == 0)
{
isMomentToMakeQueenFromPawn = true;
}
else if (side == ChessSide.red && to.horizontal == Max_X - 1)
{
isMomentToMakeQueenFromPawn = true;
}
else if (side == ChessSide.green && to.horizontal == 0)
{
isMomentToMakeQueenFromPawn = true;
}
if (isMomentToMakeQueenFromPawn)
{
if (GetFigureFromBoard(to).Type == (byte)ClassicChessItemType.pawn)
{
var ci = GetFigureFromBoard(to);
SetFigureOnBoard(to, new ClassicQueenModel(ci.Side, to));
}
}
return(true);
}
}
}
}
public void MoveChessItemPredictBackward(IChessItemModel temp, BoardPosition from, BoardPosition to)
{
SetFigureOnBoard(from, GetFigureFromBoard(to));
GetFigureFromBoard(from).Steps -= 2;
SetFigureOnBoard(to, temp);
}
public ChessItemArgs(IChessItemModel chessItem)
{
ChessItem = chessItem;
}
public IChessItemModel[,] FiguresPlacement(string short_fen, int size_x, int size_y, ChessGameType type)
{
var result = new IChessItemModel[size_x, size_y];
if (short_fen.Contains(" "))
{
short_fen = short_fen.Split(' ')[0];
}
string[] split = short_fen.Split('/');
int y = size_y - 1;
int x = 0;
foreach (var fen_item in split)
{
x = 0;
bool skip_next = false;
foreach (var char_item in fen_item)
{
if (skip_next)
{
skip_next = false;
continue;
}
if (char.IsDigit(char_item))
{
int count;
if (x + 1 < fen_item.Length && char.IsDigit(fen_item[x + 1]))
{
count = int.Parse((fen_item[x] + fen_item[x + 1]).ToString());
x++;
skip_next = true;
}
else
{
count = int.Parse(char_item.ToString());
}
for (int i = 0; i < count; i++)
{
result[x, y] = new NullChessItemModel(new BoardPosition(x, y));
x++;
}
}
else
{
var bp = new BoardPosition(x, y);
ChessSide side;
switch (type)
{
case ChessGameType.classic:
side = char.IsUpper(char_item) ? ChessSide.white : ChessSide.black;
switch (char.ToUpper(char_item))
{
case 'P':
result[x, y] = new ClassicPawnModel(side, bp);
break;
case 'R':
result[x, y] = new ClassicRookModel(side, bp);
break;
case 'N':
result[x, y] = new ClassicKnightModel(side, bp);
break;
case 'B':
result[x, y] = new ClassicBishopModel(side, bp);
break;
case 'Q':
result[x, y] = new ClassicQueenModel(side, bp);
break;
case 'K':
result[x, y] = new ClassicKingModel(side, bp);
break;
default:
throw new System.FormatException("FEN String Wrong Format!");
}
break;
case ChessGameType.los_alamos:
side = char.IsUpper(char_item) ? ChessSide.white : ChessSide.black;
switch (char.ToUpper(char_item))
{
case 'P':
result[x, y] = new LosAlamosPawnModel(side, bp);
break;
case 'R':
result[x, y] = new LosAlamosRookModel(side, bp);
break;
case 'N':
result[x, y] = new LosAlamosKnightModel(side, bp);
break;
case 'Q':
result[x, y] = new LosAlamosQueenModel(side, bp);
break;
case 'K':
result[x, y] = new LosAlamosKingModel(side, bp);
break;
default:
throw new System.FormatException("FEN String Wrong Format!");
}
break;
case ChessGameType.chaturanga:
if ("PRNQK".Contains(char_item.ToString()))
{
side = ChessSide.white;
}
else if ("prnqk".Contains(char_item.ToString()))
{
side = ChessSide.black;
}
else if ("UVWYZ".Contains(char_item.ToString()))
{
side = ChessSide.red;
}
else if ("uvwyz".Contains(char_item.ToString()))
{
side = ChessSide.green;
}
else
{
throw new System.NotImplementedException("Side was not implemented!");
}
if ("PpUu".Contains(char_item.ToString()))
{
result[x, y] = new ChaturangaPawnModel(side, bp);
}
else if ("RrVv".Contains(char_item.ToString()))
{
result[x, y] = new ChaturangaRookModel(side, bp);
}
else if ("NnWw".Contains(char_item.ToString()))
{
result[x, y] = new ChaturangaKnightModel(side, bp);
}
else if ("QqYy".Contains(char_item.ToString()))
{
result[x, y] = new ChaturangaQueenModel(side, bp);
}
else if ("KkZz".Contains(char_item.ToString()))
{
result[x, y] = new ChaturangaKingModel(side, bp);
}
else
{
throw new System.FormatException("FEN String Wrong Format!");
}
break;
case ChessGameType.circled:
side = char.IsUpper(char_item) ? ChessSide.white : ChessSide.black;
switch (char.ToUpper(char_item))
{
case 'P':
result[x, y] = new CircledPawnModel(side, bp, Direction.right);
break;
case 'T':
result[x, y] = new CircledPawnModel(side, bp, Direction.left);
break;
case 'R':
result[x, y] = new CircledRookModel(side, bp);
break;
case 'N':
result[x, y] = new CircledKnightModel(side, bp);
break;
case 'B':
result[x, y] = new CircledBishopModel(side, bp);
break;
case 'Q':
result[x, y] = new CircledQueenModel(side, bp);
break;
case 'K':
result[x, y] = new CircledKingModel(side, bp);
break;
default:
throw new System.FormatException("FEN String Wrong Format!");
}
break;
default:
throw new System.NotImplementedException("FiguresPlacement Function Not Implemented Completely!");
}
x++;
}
}
y--;
}
return(result);
}
