internal int GetPlayerPoints(eShapeType i_Piece)
{
int PlayerPoints = 0;
Piece.eSoliderType soliderType = Piece.eSoliderType.X;
Piece.eSoliderType kingType = Piece.eSoliderType.K;
if (i_Piece.Equals(eShapeType.O))
{
soliderType = Piece.eSoliderType.O;
kingType = Piece.eSoliderType.U;
}
for (int i = 0; i < this.r_TableSize; i++)
{
for (int j = 0; j < this.r_TableSize; j++)
{
Piece currentPiece = this.r_Table[i, j];
if (currentPiece.Type == soliderType)
{
PlayerPoints += 1;
}
if (currentPiece.Type == kingType)
{
PlayerPoints += 4;
}
}
}
return(PlayerPoints);
}
internal bool isLegalDiagonalMove(eShapeType i_Shape)
{
bool isLegalMove = false;
switch (i_Shape)
{
case eShapeType.X:
if ((m_CurrentPiece.Row - 1 == m_TargetPiece.Row) && (m_CurrentPiece.Column - 1 == m_TargetPiece.Column))
{
isLegalMove = true;
}
if ((m_CurrentPiece.Row - 1 == m_TargetPiece.Row) && (m_CurrentPiece.Column + 1 == m_TargetPiece.Column))
{
isLegalMove = true;
}
break;
case eShapeType.O:
if ((m_CurrentPiece.Row + 1 == m_TargetPiece.Row) && (m_CurrentPiece.Column - 1 == m_TargetPiece.Column))
{
isLegalMove = true;
}
if ((m_CurrentPiece.Row + 1 == m_TargetPiece.Row) && (m_CurrentPiece.Column + 1 == m_TargetPiece.Column))
{
isLegalMove = true;
}
break;
}
return(isLegalMove);
}
private bool isValidDiagonalKingMove(eShapeType i_ShapeOfMove)
{
bool isValidKingMove = false;
if ((m_FromSquare.Row - 1 == m_ToSquare.Row) && (m_FromSquare.Column - 1 == m_ToSquare.Column))
{
isValidKingMove = true;
}
if ((m_FromSquare.Row - 1 == m_ToSquare.Row) && (m_FromSquare.Column + 1 == m_ToSquare.Column))
{
isValidKingMove = true;
}
if ((m_FromSquare.Row + 1 == m_ToSquare.Row) && (m_FromSquare.Column - 1 == m_ToSquare.Column))
{
isValidKingMove = true;
}
if ((m_FromSquare.Row + 1 == m_ToSquare.Row) && (m_FromSquare.Column + 1 == m_ToSquare.Column))
{
isValidKingMove = true;
}
return(isValidKingMove);
}
private bool isValidDiagonalMove(eShapeType i_Shape)
{
bool isValidMove = false;
switch (i_Shape)
{
case eShapeType.X:
if ((m_FromSquare.Row - 1 == m_ToSquare.Row) && (m_FromSquare.Column - 1 == m_ToSquare.Column))
{
isValidMove = true;
}
if ((m_FromSquare.Row - 1 == m_ToSquare.Row) && (m_FromSquare.Column + 1 == m_ToSquare.Column))
{
isValidMove = true;
}
break;
case eShapeType.O:
if ((m_FromSquare.Row + 1 == m_ToSquare.Row) && (m_FromSquare.Column - 1 == m_ToSquare.Column))
{
isValidMove = true;
}
if ((m_FromSquare.Row + 1 == m_ToSquare.Row) && (m_FromSquare.Column + 1 == m_ToSquare.Column))
{
isValidMove = true;
}
break;
}
return(isValidMove);
}
public bool CheckIsLegalMove(eShapeType i_ShapeOfPlayer)
{
bool isLegalMove = true;
switch (i_ShapeOfPlayer)
{
case eShapeType.X:
if (m_CurrentPiece.Type != Piece.eSoliderType.X && m_CurrentPiece.Type != Piece.eSoliderType.K)
{
isLegalMove = false;
}
else
{
if (m_TargetPiece.Type != Piece.eSoliderType.Empty)
{
isLegalMove = false;
}
else
{
if (m_CurrentPiece.Type == Piece.eSoliderType.X)
{
isLegalMove = isLegalDiagonalMove(eShapeType.X);
}
else
{
isLegalMove = isLegalDiagonalKingMove();
}
}
}
break;
case eShapeType.O:
if (m_CurrentPiece.Type != Piece.eSoliderType.O && m_CurrentPiece.Type != Piece.eSoliderType.U)
{
isLegalMove = false;
}
else
{
if (m_TargetPiece.Type != Piece.eSoliderType.Empty)
{
isLegalMove = false;
}
else
{
if (m_CurrentPiece.Type == Piece.eSoliderType.O)
{
isLegalMove = isLegalDiagonalMove(eShapeType.O);
}
else
{
isLegalMove = isLegalDiagonalKingMove();
}
}
}
break;
}
return(isLegalMove);
}
public Player(eShapeType i_Shape, string i_PlayerName, ePlayerType i_PlayerType)
{
this.m_Shape = i_Shape;
this.m_PlayerName = i_PlayerName;
v_JumpTurn = false;
this.m_PlayerType = i_PlayerType;
this.m_Points = 0;
}
internal Player(eShapeType shape, string PlayerName, ePlayerType i_PlayerType)
{
this.m_Shape = shape;
this.m_PlayerName = PlayerName;
v_JumpTurn = false;
this.m_PlayerType = i_PlayerType;
this.m_Points = 0;
}
internal int GetPointsOfPlayer(eShapeType i_Piece)
{
int countPlayerPoints = 0;
switch (i_Piece)
{
case (eShapeType.X):
for (int i = 0; i < this.m_Size; i++)
{
for (int j = 0; j < this.m_Size; j++)
{
Square currentSquare = this.m_Board[i, j];
if (currentSquare.Type == eSquareType.X)
{
countPlayerPoints += 1;
}
if (currentSquare.Type == eSquareType.K)
{
countPlayerPoints += 4;
}
}
}
break;
case (eShapeType.O):
for (int i = 0; i < this.m_Size; i++)
{
for (int j = 0; j < this.m_Size; j++)
{
Square currentSquare = this.m_Board[i, j];
if (currentSquare.Type == eSquareType.O)
{
countPlayerPoints += 1;
}
if (currentSquare.Type == eSquareType.U)
{
countPlayerPoints += 4;
}
}
}
break;
}
return(countPlayerPoints);
}
private List <Move> getListOfJumpsForPiece(eShapeType i_Shape, Piece i_Solider)
{
int SoliderRow = i_Solider.Row;
int SoliderColumn = i_Solider.Column;
Move currentMove;
List <Move> leggalJumpsForPiece = r_GameTable.GetPlayerJumpsList(i_Shape);
for (int i = 0; i < leggalJumpsForPiece.Count; i++)
{
currentMove = leggalJumpsForPiece[i];
if (currentMove.CurrentPiece.Row != SoliderRow || currentMove.CurrentPiece.Column != SoliderColumn)
{
leggalJumpsForPiece.Remove(currentMove);
}
}
return(leggalJumpsForPiece);
}
internal List <Move> GetPlayerJumpsList(eShapeType i_Shape)
{
List <Move> legalJumps = new List <Move>();
short TableSize = this.TableSize;
int jumpMove = 1;
Piece.eSoliderType soliderType = Piece.eSoliderType.X;
Piece.eSoliderType kingType = Piece.eSoliderType.K;
for (int r = 0; r < TableSize; r++)
{
for (int c = 0; c < TableSize; c++)
{
switch (i_Shape)
{
case eShapeType.O:
if ((getSoliderTypeInTable(r, c) == Piece.eSoliderType.O) || (getSoliderTypeInTable(r, c) == Piece.eSoliderType.U)) //regular piece of O
{
JumpMove(r, c, ref legalJumps, soliderType, kingType, jumpMove);
}
if (getSoliderTypeInTable(r, c) == Piece.eSoliderType.U) //King of O
{
JumpMove(r, c, ref legalJumps, soliderType, kingType, (jumpMove * -1));
}
break;
case eShapeType.X:
soliderType = Piece.eSoliderType.O;
kingType = Piece.eSoliderType.U;
if ((getSoliderTypeInTable(r, c) == Piece.eSoliderType.X) || (getSoliderTypeInTable(r, c) == Piece.eSoliderType.K)) //regular piece of X
{
JumpMove(r, c, ref legalJumps, soliderType, kingType, (jumpMove * -1));
}
if (getSoliderTypeInTable(r, c) == Piece.eSoliderType.K) //king of X
{
JumpMove(r, c, ref legalJumps, soliderType, kingType, jumpMove);
}
break;
}
}
}
return(legalJumps);
}
private List <Move> getListOfJumpsForPiece(eShapeType i_Shape, Square i_Square)
{
int squareRow = i_Square.Row;
int squareColumn = i_Square.Column;
Move currentMove;
List <Move> leggalJumpsForPiece = m_BoardGame.GetListOfPlayerJumps(i_Shape);
for (int i = 0; i < leggalJumpsForPiece.Count; i++)
{
currentMove = leggalJumpsForPiece[i];
if (currentMove.GetFromPiece().Row != squareRow || currentMove.GetFromPiece().Column != squareColumn)
{
leggalJumpsForPiece.Remove(currentMove);
}
}
return(leggalJumpsForPiece);
}
internal List <Move> GetListOfPlayerDiagonalMoves(eShapeType i_Shape)
{
List <Move> legalMoves = new List <Move>();
short TableSize = this.TableSize;
int diagonalMove = 1;
for (int r = 0; r < TableSize; r++)
{
for (int c = 0; c < TableSize; c++)
{
switch (i_Shape)
{
case eShapeType.O:
if ((getSoliderTypeInTable(r, c) == Piece.eSoliderType.O) ||
(getSoliderTypeInTable(r, c) == Piece.eSoliderType.U)) //regular piece of O
{
MoveDiagonal(r, c, ref legalMoves, diagonalMove);
}
if (getSoliderTypeInTable(r, c) == Piece.eSoliderType.U) //King of O
{
MoveDiagonal(r, c, ref legalMoves, (diagonalMove * -1));
}
break;
case eShapeType.X:
if ((getSoliderTypeInTable(r, c) == Piece.eSoliderType.X) ||
(getSoliderTypeInTable(r, c) == Piece.eSoliderType.K)) //regular piece of X
{
MoveDiagonal(r, c, ref legalMoves, (diagonalMove * -1));
}
if (getSoliderTypeInTable(r, c) == Piece.eSoliderType.K) //King of X
{
MoveDiagonal(r, c, ref legalMoves, diagonalMove);
}
break;
}
}
}
return(legalMoves);
}
internal bool CheckIsValidMove(eShapeType i_ShapeOfPlayer)
{
bool isValidMove = true;
switch (i_ShapeOfPlayer)
{
case eShapeType.X:
if (m_FromSquare.Type != eSquareType.X && m_FromSquare.Type != eSquareType.K)
{
isValidMove = false;
}
else
{
if (m_ToSquare.Type != eSquareType.None)
{
isValidMove = false;
}
else
{
if (m_FromSquare.Type == eSquareType.X)
{
isValidMove = isValidDiagonalMove(eShapeType.X);
}
else
{
isValidMove = isValidDiagonalKingMove(eShapeType.X);
}
}
}
break;
case eShapeType.O:
if (m_FromSquare.Type != eSquareType.O && m_FromSquare.Type != eSquareType.U)
{
isValidMove = false;
}
else
{
if (m_ToSquare.Type != eSquareType.None)
{
isValidMove = false;
}
else
{
if (m_FromSquare.Type == eSquareType.O)
{
isValidMove = isValidDiagonalMove(eShapeType.O);
}
else
{
isValidMove = isValidDiagonalKingMove(eShapeType.O);
}
}
}
break;
}
return(isValidMove);
}
internal List <Move> GetListOfPlayerJumps(eShapeType i_Shape)
{
List <Move> leggalJumps = new List <Move>();
short boardSize = this.GetSize();
for (int r = 0; r < boardSize; r++)
{
for (int c = 0; c < boardSize; c++)
{
switch (i_Shape)
{
case eShapeType.O:
if (getTypeOfSquareInBoard(r, c) == eSquareType.O) //regular piece of O
{
if ((getTypeOfSquareInBoard(r + 2, c - 2) == eSquareType.None) && (getTypeOfSquareInBoard(r + 1, c - 1) == eSquareType.X || getTypeOfSquareInBoard(r + 1, c - 1) == eSquareType.K))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r + 2, c - 2)));
}
if ((getTypeOfSquareInBoard(r + 2, c + 2) == eSquareType.None) && (getTypeOfSquareInBoard(r + 1, c + 1) == eSquareType.X || getTypeOfSquareInBoard(r + 1, c + 1) == eSquareType.K))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r + 2, c + 2)));
}
}
if (getTypeOfSquareInBoard(r, c) == eSquareType.U) //King of O
{
if ((getTypeOfSquareInBoard(r + 2, c - 2) == eSquareType.None) && (getTypeOfSquareInBoard(r + 1, c - 1) == eSquareType.X || getTypeOfSquareInBoard(r + 1, c - 1) == eSquareType.K))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r + 2, c - 2)));
}
if ((getTypeOfSquareInBoard(r + 2, c + 2) == eSquareType.None) && (getTypeOfSquareInBoard(r + 1, c + 1) == eSquareType.X || getTypeOfSquareInBoard(r + 1, c + 1) == eSquareType.K))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r + 2, c + 2)));
}
if ((getTypeOfSquareInBoard(r - 2, c - 2) == eSquareType.None) && (getTypeOfSquareInBoard(r - 1, c - 1) == eSquareType.X || getTypeOfSquareInBoard(r - 1, c - 1) == eSquareType.K))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r - 2, c - 2)));
}
if ((getTypeOfSquareInBoard(r - 2, c + 2) == eSquareType.None) && (getTypeOfSquareInBoard(r - 1, c + 1) == eSquareType.X || getTypeOfSquareInBoard(r - 1, c + 1) == eSquareType.K))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r - 2, c + 2)));
}
}
break;
case eShapeType.X:
if (getTypeOfSquareInBoard(r, c) == eSquareType.X) //regular piece of X
{
if ((getTypeOfSquareInBoard(r - 2, c - 2) == eSquareType.None) && (getTypeOfSquareInBoard(r - 1, c - 1) == eSquareType.O || getTypeOfSquareInBoard(r - 1, c - 1) == eSquareType.U))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r - 2, c - 2)));
}
if ((getTypeOfSquareInBoard(r - 2, c + 2) == eSquareType.None) && (getTypeOfSquareInBoard(r - 1, c + 1) == eSquareType.O || getTypeOfSquareInBoard(r - 1, c + 1) == eSquareType.U))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r - 2, c + 2)));
}
}
if (getTypeOfSquareInBoard(r, c) == eSquareType.K) //king of X
{
if ((getTypeOfSquareInBoard(r + 2, c - 2) == eSquareType.None) && (getTypeOfSquareInBoard(r + 1, c - 1) == eSquareType.O || getTypeOfSquareInBoard(r + 1, c - 1) == eSquareType.U))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r + 2, c - 2)));
}
if ((getTypeOfSquareInBoard(r + 2, c + 2) == eSquareType.None) && (getTypeOfSquareInBoard(r + 1, c + 1) == eSquareType.O || getTypeOfSquareInBoard(r + 1, c + 1) == eSquareType.U))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r + 2, c + 2)));
}
if ((getTypeOfSquareInBoard(r - 2, c - 2) == eSquareType.None) && (getTypeOfSquareInBoard(r - 1, c - 1) == eSquareType.O || getTypeOfSquareInBoard(r - 1, c - 1) == eSquareType.U))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r - 2, c - 2)));
}
if ((getTypeOfSquareInBoard(r - 2, c + 2) == eSquareType.None) && (getTypeOfSquareInBoard(r - 1, c + 1) == eSquareType.O || getTypeOfSquareInBoard(r - 1, c + 1) == eSquareType.U))
{
leggalJumps.Add(new Move(GetSquare(r, c), GetSquare(r - 2, c + 2)));
}
}
break;
}
}
}
return(leggalJumps);
}
