public static int GetPieceCountRatio(Board board, PieceEnum player)
{
int[] pieceCounts = GetPieceCount(board, player);
int result = 100 * (pieceCounts[0] - pieceCounts[1]) / (pieceCounts[0] + pieceCounts[1]);
return(result);
}
public Piece CreatePiece(PieceEnum type, ColorEnum color)
{
switch (type)
{
case PieceEnum.RightQueen:
return(new Queen(color, type));
case PieceEnum.LeftQueen:
return(new Queen(color, type));
case PieceEnum.RightKing:
return(new King(color, type));
case PieceEnum.LeftKing:
return(new King(color, type));
case PieceEnum.Rook:
return(new Rook(color, type));
case PieceEnum.Knight:
return(new Knight(color, type));
case PieceEnum.Bishop:
return(new Bishop(color, type));
case PieceEnum.Pawn:
return(new Pawn(color, type));
default:
throw new Exception("Unsupported piece type.");
}
}
private int[] GetSuccesfulMoveInDirection(int[] boardSquareCoordinates, int dirX, int dirY, PieceEnum currentPlayer)
{
PieceEnum opponent = currentPlayer.GetOpponent();
int hasBeatableEnemies = 0;
int tempY = boardSquareCoordinates[0];
int tempX = boardSquareCoordinates[1];
//move to next checked square
tempX += dirX;
tempY += dirY;
while (IsInRange(tempY) && IsInRange(tempX)) //while inside board borders
{
if (this.board[tempX, tempY] == opponent) //found opponent
{
hasBeatableEnemies = 1;
}
else if (hasBeatableEnemies == 1 && this.board[tempX, tempY] == PieceEnum.none)//there are beatable opponents
{
return(new int[] { 1, tempY, tempX, dirX, dirY });
}
else if (this.board[tempX, tempY] != opponent)//found no enemies, reached dead end
{
break;
}
tempX += dirX;
tempY += dirY;
}
return(new int[] { 0, tempY, tempX, dirX, dirY });//no beatable enemies found
}
public static int GetValue(this PieceEnum p)
{
//score value
switch (p)
{
case PieceEnum.Pawn:
return(10);
case PieceEnum.Knight:
return(30);
case PieceEnum.Bishop:
return(30);
case PieceEnum.Rook:
return(50);
case PieceEnum.Queen:
return(90);
case PieceEnum.King:
return(900);
default:
return(0);
}
}
public static int GetBlackHoleRatio(Board board, PieceEnum player)
{
int myPieces = 0;
int opPieces = 0;
PieceEnum opponent = player.GetOpponent();
int blackHoleX = board.blackHoleCoords[0];
int blackHoleY = board.blackHoleCoords[1];
for (int i = -1; i < 2; i++)
{
for (int j = -1; j < 2; j++)
{
if (board.board[blackHoleY + i, blackHoleX + j] == player)
{
myPieces++;
}
if (board.board[blackHoleY + i, blackHoleX + j] == opponent)
{
opPieces++;
}
}
}
int result = 100 * (myPieces - opPieces) / (myPieces + opPieces + 1);
return(result);
}
static int heuristic(Board board, IPlayer player, bool isMax)
{
PieceEnum playerColor = player.color;
//int result;
//switch (GetGamePhase(board))
//{
// case GamePhase.Early:
// //return -1000 * GetCornerRatio(board, playerColor) + 50 * GetMobility(board, playerColor);
// //return 5 * boardHeuristic(board, player) + 50 * GetMobility(board, playerColor);
// result = -1000 * GetCornerRatio(board, playerColor) + 10 * boardHeuristic(board, player) + 100 * GetMobility(board, playerColor);
// break;
// case GamePhase.Mid:
// //return -1000 * GetCornerRatio(board, playerColor) + 20 * GetMobility(board, playerColor) - 10 * GetPieceCountRatio(board, playerColor) + 100 * GetParity(board);
// //return 5 * boardHeuristic(board, player) + 20 * GetMobility(board, playerColor) - 10 * GetPieceCountRatio(board, playerColor);// + 100 * GetParity(board);
// result = -1000 * GetCornerRatio(board, playerColor) + 10 * boardHeuristic(board, player) + 80 * GetMobility(board, playerColor) - 10 * GetPieceCountRatio(board, playerColor);// + 100 * GetParity(board);
// break;
// case GamePhase.Late:
// default:
// //return -1000 * GetCornerRatio(board, playerColor) + 100 * GetMobility(board, playerColor) - 500 * GetPieceCountRatio(board, playerColor) + 500 * GetParity(board);
// //return 5 * boardHeuristic(board, player) + 100 * GetMobility(board, playerColor) - 500 * GetPieceCountRatio(board, playerColor);// + 500 * GetParity(board);
// result = -1000 * GetCornerRatio(board, playerColor) + 10 * boardHeuristic(board, player) + 100 * GetMobility(board, playerColor) - 500 * GetPieceCountRatio(board, playerColor);// + 500 * GetParity(board);
// break;
//}
////Console.WriteLine("Total: " + result);
//return result;
int boardH = boardHeuristic(board, player, isMax);
//int mobility = GetMobility(board, playerColor);
//Console.WriteLine("HH: " + (boardH + 10 * mobility) + " BoardH: " + boardH + ". MobilityH: " + mobility);
return(boardH);// - 5*mobility;
//return -1000 * GetCornerRatio(board, playerColor) + boardH + mobility;
//return GetScore(board, playerColor);
}
public int[][] GetValidMovesList(PieceEnum currentPlayer)
{
int[][][] movesArray = new int[64][][];
int pos = 0;
for (int i = 0; i < boardLength; i++)
{
for (int j = 0; j < boardLength; j++)
{
if (board[i, j] == currentPlayer)//have to check possible moves for that piece
{
movesArray[pos++] = GetValidMovesForAPiece(new int[] { j, i }, currentPlayer).ToArray();
}
}
}
//Using this to increase performance
List <int[]> validMovesList = new List <int[]>();
for (int i = 0; i < pos; i++)
{
for (int j = 0; j < movesArray[i].Length; j++)
{
validMovesList.Add(movesArray[i][j]);
}
}
return(validMovesList.ToArray());
}
private Color GetColorByPieceType(PieceEnum pieceEnum)
{
switch (pieceEnum)
{
case PieceEnum.I:
return(Color.Red);
case PieceEnum.L:
return(Color.Yellow);
case PieceEnum.J:
return(Color.Purple);
case PieceEnum.T:
return(Color.Brown);
case PieceEnum.O:
return(Color.Blue);
case PieceEnum.S:
return(Color.Green);
case PieceEnum.Z:
return(Color.Teal);
default:
return(Color.DarkGray);
}
}
//LEGACY functions
public static int GetMobility(Board board, PieceEnum player)
{
int currentPlayerMovesLength = board.GetValidMovesList(player).Length;
int opponentMovesLength = board.GetValidMovesList(player.GetOpponent()).Length;
int result = currentPlayerMovesLength - opponentMovesLength;
return(result);
}
protected Piece(Piece piece)
{
_flags = piece._flags;
_positionPoint2D = piece._positionPoint2D;
Letter = piece.Letter;
Name = piece.Name;
MoveSet = piece.MoveSet;
Color = piece.Color;
}
public static IEnumerable <(PieceEnum Piece, SquareEnum Square)> Create(PieceEnum piece, SquareEnum square, IPositionImpl position)
{
var moves = Create(piece);
foreach (var m in moves.GetIteratorFor(square, position, piece).Iterate())
{
yield return(m.Piece, m.Square);
}
}
public static PieceEnum FromSanToPromoted(this string str, PieceEnum piece)
{
if (promoteDict.ContainsKey(str.LastOrDefault().ToString()))
{
return(str.FirstOrDefault().ToString().ToPiece().Match(
None: () => piece,
Some: s => s));
}
else
{
return(piece);
}
}
public int UpdateBeatPieces(List <int[]> takenCoordsAndDirs, IPlayer currentPlayer)
{
PieceEnum currentTurn = currentPlayer.color;
int changedPieces = 0;
foreach (var XYDirection in takenCoordsAndDirs)
{
changedPieces = ChangePieces(XYDirection[0], XYDirection[1], XYDirection[2], XYDirection[3], currentTurn);
}
boardUpdateEvent?.Invoke();
return(changedPieces);
}
public void AssertMovesFor(string fenString, PieceEnum pieceEnum, SquareEnum[] expected)
{
Option <Fen> fen = Fen.Of(fenString);
Option <Position> position = Position.Of(fen);
Option <PieceEnum> pieceOpt = pieceEnum;
Option <Selected> selected = pieceOpt.Bind(piece => position.Bind(p => Selected.Of(piece, p.GetIteratorFor(piece), p)));
selected.Match(
None: () => Assert.Fail(),
Some: s => position.Match(
None: () => Assert.Fail(),
Some: p => AssertSelected(s, expected.ToList())
));
}
public static PieceEnum GetOpponent(this PieceEnum colour)
{
if (colour == PieceEnum.black)
{
return(PieceEnum.white);
}
else if (colour == PieceEnum.white)
{
return(PieceEnum.black);
}
else
{
return(PieceEnum.none);
}
}
public int ChangePieces(int coordX, int coordY, int x, int y, PieceEnum colorCurrent)
{
int changed = 0;
int[] XYDirs = new int[] { coordX, coordY, x, y };
//Console.WriteLine("{1} [{0}]", string.Join(", ", XYDirs), "XYDirs");
board[coordY, coordX] = colorCurrent;
while (board[coordY - x, coordX - y] == colorCurrent.GetOpponent())
{
coordX -= y;
coordY -= x;
board[coordY, coordX] = colorCurrent;
changed++;
}
return(changed);
}
private Move(PieceEnum piece, SquareEnum?from = null, SquareEnum?to = null, PieceEnum?promote = null)
{
Piece = piece;
Rokade = RokadeEnum.None;
if (from.HasValue)
{
From = from.Value;
Promote = Piece;
}
if (to.HasValue)
{
To = to.Value;
}
if (promote.HasValue)
{
Promote = promote.Value;
}
}
public static int GetCornerRatio(Board board, PieceEnum player)
{
int myCorners = 0;
int opCorners = 0;
PieceEnum opponent = player.GetOpponent();
if (board.board[0, 0] == player)
{
myCorners++;
}
if (board.board[7, 0] == player)
{
myCorners++;
}
if (board.board[0, 7] == player)
{
myCorners++;
}
if (board.board[7, 7] == player)
{
myCorners++;
}
if (board.board[0, 0] == opponent)
{
opCorners++;
}
if (board.board[7, 0] == opponent)
{
opCorners++;
}
if (board.board[0, 7] == opponent)
{
opCorners++;
}
if (board.board[7, 7] == opponent)
{
opCorners++;
}
int result = 100 * (myCorners - opCorners) / (myCorners + opCorners + 1);
return(result);
}
public static Bitmap GetInstance(PieceEnum type, ColorEnum color)
{
if (instances == null)
{
instances = new Dictionary <PieceEnum, Dictionary <ColorEnum, Bitmap> >();
}
if (!instances.ContainsKey(type))
{
instances.Add(type, new Dictionary <ColorEnum, Bitmap>());
}
if (!instances[type].ContainsKey(color))
{
instances[type].Add(color, CropImage(type, color));
}
return(instances[type][color]);
}
protected Piece(Point2D positionPoint2D, Color color, string letter, string name, bool moveRepeat)
{
Name = name;
_flags = moveRepeat
? PieceEnum.InPlay |
PieceEnum.MoveRepeat
: PieceEnum.InPlay;
Letter = letter;
_positionPoint2D = positionPoint2D;
Color = color;
if (positionPoint2D.X % 2 == positionPoint2D.Y % 2)
{
FlagsHelper.Set(ref _flags, PieceEnum.LightColor);
}
else
{
FlagsHelper.Unset(ref _flags, PieceEnum.LightColor);
}
}
static public void Main(string[] args)
{
int[] blackHoleCoords = GetBlackHoleCoords();
PieceEnum testerColour = GetTesterColour();
IPlayer tester = new HumanPlayer(testerColour);
IPlayer bot = new AIPlayer(GetOpponentColour(testerColour));
if (testerColour == PieceEnum.black)
{
game = new Game(tester, bot);
}
else
{
game = new Game(bot, tester);
}
Game.gameEndEvent += gameEndHandler;
Game.nextMoveEvent += nextMoveHandler;
game.InitGame(blackHoleCoords);
game.PlayRound();
}
public Piece(PieceEnum pieceToCreate, int posX, int posY)
{
this.positionX = posX;
this.positionY = posY;
this.pieceType = pieceToCreate;
switch (pieceToCreate)
{
case PieceEnum.I:
ShapeIPiece();
break;
case PieceEnum.L:
ShapeLPiece();
break;
case PieceEnum.J:
ShapeJPiece();
break;
case PieceEnum.T:
ShapeTPiece();
break;
case PieceEnum.O:
ShapeOPiece();
break;
case PieceEnum.S:
ShapeSPiece();
break;
case PieceEnum.Z:
ShapeZPiece();
break;
default:
throw new Exception("Piece not implemented");
}
}
public static int[] GetPieceCount(Board board, PieceEnum playerColor)
{
int playerPieceCount = 0;
int opponentPieceCount = 0;
PieceEnum opponentColor = playerColor.GetOpponent();
for (int i = 0; i < board.boardLength; i++)
{
for (int j = 0; j < board.boardLength; j++)
{
if (board.board[i, j] == playerColor)
{
playerPieceCount++;
}
else if (board.board[i, j] == opponentColor)
{
opponentPieceCount++;
}
}
}
return(new int[] { playerPieceCount, opponentPieceCount });
}
private List <int[]> GetValidMovesForAPiece(int[] boardSquareCoordinates, PieceEnum currentPlayer)
{
List <int[]> validMovesList = new List <int[]>();
int[] array;
for (int dirX = -1; dirX < 2; dirX++)
{
for (int dirY = -1; dirY < 2; dirY++)
{
if (dirX == 0 && dirY == 0)
{
continue;
}
array = GetSuccesfulMoveInDirection(boardSquareCoordinates, dirX, dirY, currentPlayer);
if (array[0] == 1)
{
validMovesList.Add(new int[] { array[1], array[2], array[3], array[4] });
}
}
}
return(validMovesList);
}
private static Moves Create(PieceEnum piece)
{
switch (piece)
{
case PieceEnum.Knight:
return(KnightMoves.Get());
case PieceEnum.Bishop:
return(BishopMoves.Get());
case PieceEnum.Rook:
return(RookMoves.Get());
case PieceEnum.Queen:
return(QueenMoves.Get());
case PieceEnum.King:
return(KingMoves.Get());
case PieceEnum.Pawn:
return(PawnMoves.Get());
}
return(null);
}
public Bishop(ColorEnum color, PieceEnum type) : base(color, type)
{
Value = 3;
}
private Move(PieceEnum piece, RokadeEnum rokade)
{
Piece = piece;
Rokade = rokade;
}
public Position.PiecesIterator <PieceEnum> GetIteratorFor(SquareEnum square, Option <Position> position, PieceEnum pieceEnum = PieceEnum.Bishop) => position.Match(
public static Option <Selected> Of(PieceEnum piece, PiecesIterator <PieceEnum> iterator, Option <Position> position) => Some(new Selected(piece, iterator, position));
private Selected(PieceEnum piece, PiecesIterator <PieceEnum> iterator, Option <Position> position)
{
this.Piece = piece;
this.Iterator = iterator;
this.Position = position;
}
