public static Checkerboard MakeDefaultCheckerboard()
{
var checkerboard = new Checkerboard();
const int NumFilledRows = 3;
for (int y = 0; y < NumFilledRows; ++y)
{
for (int x = 0; x < checkerboard.size.x; ++x)
{
if ((x % 2 == 0) ^ (y % 2 == 0))
{
continue;
}
checkerboard.AddPieceAt(new Vector2Int(x, y), Checkerboard.TileState.White);
}
}
for (int y = checkerboard.size.y - NumFilledRows; y < checkerboard.size.y; ++y)
{
for (int x = 0; x < checkerboard.size.x; ++x)
{
if ((x % 2 == 0) ^ (y % 2 == 0))
{
continue;
}
checkerboard.AddPieceAt(new Vector2Int(x, y), Checkerboard.TileState.Black);
}
}
return(checkerboard);
}
public IEnumerable <Move> GetMoves(Checkerboard checkerboard, Pawn pawn)
{
var movesUpperRight = checkerboard.FindMovesAlongDirection(pawn, new Position(1, 1));
var movesUpperLeft = checkerboard.FindMovesAlongDirection(pawn, new Position(1, -1));
var movesLowerRight = checkerboard.FindMovesAlongDirection(pawn, new Position(-1, 1));
var movesLowerLeft = checkerboard.FindMovesAlongDirection(pawn, new Position(-1, -1));
foreach (var move in movesUpperRight)
{
yield return(move);
}
foreach (var move in movesUpperLeft)
{
yield return(move);
}
foreach (var move in movesLowerRight)
{
yield return(move);
}
foreach (var move in movesLowerLeft)
{
yield return(move);
}
}
public static void ReleaseResources()
{
//if (StudGridTexture != null)
//{
// StudGridTexture.Dispose();
// StudGridTexture = null;
//}
if (StudConnectionGrid != null)
{
StudConnectionGrid.Dispose();
StudConnectionGrid = null;
}
if (Checkerboard != null)
{
Checkerboard.Dispose();
Checkerboard = null;
}
if (SelectionIcons != null)
{
SelectionIcons.Dispose();
SelectionIcons = null;
}
}
private void CheckerboardOnPieceRemoved(Checkerboard sender, Vector2Int position)
{
ClearSelection();
grid[position.x, position.y].pieceView.Capture();
grid[position.x, position.y].pieceView = null;
}
public IEnumerable <Move> GetMoves(Checkerboard checkerboard, Pawn pawn)
{
Position posPlus1;
Position posPlus2;
if (pawn.PawnColor == PawnColor.White)
{
posPlus1 = pawn.Position + new Position(0, 1);
posPlus2 = posPlus1 + new Position(0, 1);
}
else
{
posPlus1 = pawn.Position - new Position(0, 1);
posPlus2 = posPlus1 - new Position(0, 1);
}
bool canMove1SquareForward = checkerboard.IsEmptyButExists(posPlus1);
bool canMove2SquareForward = pawn.Position.Digit == (pawn.PawnColor == PawnColor.White ? 1 : 6) && checkerboard.IsEmptyButExists(posPlus2);
if (canMove1SquareForward)
{
yield return(checkerboard.GetMove(pawn, posPlus1));
if (canMove2SquareForward)
{
yield return(checkerboard.GetMove(pawn, posPlus2));
}
}
foreach (var take in GetTakes(checkerboard, pawn))
{
yield return(checkerboard.GetMove(pawn, take.NewPawnPos, take.TakenPawn));
}
}
Move?FindMove(Checkerboard checkerboard, Pawn pawn, Position position)
{
if (checkerboard.IsEmptyButExists(position))
{
return(checkerboard.GetMove(pawn, position));
}
return(null);
}
void OnTriggerEnter(Collider col)
{
if (lastCubeMoved == this.gameObject && Checkerboard.isCube(col.gameObject))
{
onTopOf = col.gameObject;
GoTo(transform.position + new Vector3(0, Checkerboard.moveUp * 2.0f, 0));
}
}
void OnTriggerEnter(Collider col)
{
if (lastCubeMoved == this.gameObject && Checkerboard.isCube(col.gameObject))
{
onTopOf = col.gameObject;
GoTo(transform.position + (2.0f * Checkerboard.moveUp) * (GameObject.Find("NegativeSpaceCenter").transform.up));
}
}
void Start()
{
_checkerboard = GameObject.Find("Checkerboard").GetComponent <Checkerboard>();
clickEvent = new ClickEvent();
attitude = Quaternion.identity;
_filteredRotation = new AdaptiveDoubleExponentialQuaternion();
}
private void CheckerboardOnMultiCapture(Checkerboard sender, Vector2Int position)
{
if (ownColor != sender.currentPlayerColor)
{
return;
}
Select(position);
}
public void On(NotifyTableState message)
{
Assert.IsTrue(isEntered);
checkerboard = message.checkerboard;
checkerboardView.SetCheckerboard(checkerboard);
otherPlayerInfo = message.otherPlayerInfo;
}
void InitializeCheckerboard()
{
IMoveStrategy pawnMoveStrategy = new PawnMoveStrategy();
IMoveStrategy bishopMoveStrategy = new BishopMoveStrategy();
IMoveStrategy knightMoveStrategy = new KnightMoveStrategy();
IMoveStrategy rookMoveStrategy = new RookMoveStrategy();
IMoveStrategy kingMoveStrategy = new KingMoveStrategy();
IMoveStrategy queenMoveStrategy = new QueenMoveStrategy();
MainCheckerboard = new Checkerboard(new List <Pawn>()
{
new Pawn(new Position('h', 8), PawnColor.White, PawnType.King, kingMoveStrategy),
new Pawn(new Position('h', 1), PawnColor.Black, PawnType.King, kingMoveStrategy),
new Pawn(new Position('f', 6), PawnColor.White, PawnType.Pawn, pawnMoveStrategy),
new Pawn(new Position('c', 3), PawnColor.White, PawnType.Pawn, pawnMoveStrategy),
new Pawn(new Position('d', 4), PawnColor.Black, PawnType.Bishop, bishopMoveStrategy),
new Pawn(new Position('e', 4), PawnColor.White, PawnType.Bishop, bishopMoveStrategy),
new Pawn(new Position('e', 2), PawnColor.Black, PawnType.Knight, knightMoveStrategy),
new Pawn(new Position('c', 6), PawnColor.Black, PawnType.Rook, rookMoveStrategy),
new Pawn(new Position('a', 7), PawnColor.White, PawnType.Queen, queenMoveStrategy),
new Pawn(new Position('e', 5), PawnColor.Black, PawnType.Queen, queenMoveStrategy),
});
var pieces = MainCheckerboard.GetAllPawns();
PiecesOnBoard.Text = $"Pawns: {pieces.Count()}{Environment.NewLine}{Environment.NewLine}";
foreach (var pawn in pieces)
{
PiecesOnBoard.Text += $"{pawn.PawnColor} {pawn.PawnType}, {pawn.Position.Letter}{pawn.Position.Digit},{Environment.NewLine}";
var moves = pawn.GetAvailableMoves(MainCheckerboard);
if (moves?.Any() == true)
{
PiecesOnBoard.Text += $"Moves: ";
foreach (var move in moves)
{
PiecesOnBoard.Text += $"{move.NewPawnPos.Letter}{move.NewPawnPos.Digit}, ";
}
var takes = pawn.GetAvailableTakes(moves);
if (takes?.Any() == true)
{
PiecesOnBoard.Text += $"{Environment.NewLine}Takes: ";
foreach (var move in takes)
{
PiecesOnBoard.Text += $"{move.NewPawnPos.Letter}{move.NewPawnPos.Digit}, ";
}
}
}
PiecesOnBoard.Text += Environment.NewLine;
PiecesOnBoard.Text += Environment.NewLine;
}
}
void Start()
{
Assert.IsNotNull(checkerboardView);
checkerboard = CheckersHelper.MakeDefaultCheckerboard();
checkerboardView.SetCheckerboard(checkerboard);
checkerboardView.SetControlsEnabled(true);
checkerboardView.OnMoveRequest += OnMoveRequest;
//checkerboard.AddAt(new Vector2Int(3, 3), Checkerboard.TileState.Black);
}
bool CanTakeEnPassant(Checkerboard checkerboard, Pawn pawn, Pawn sidePawn, Position finalPawnPos, out Pawn sidePosPawn)
{
sidePosPawn = null;
return(pawn.Position.Digit == (pawn.PawnColor == PawnColor.White ? 4 : 3) &&
pawn.AreOppositeColor(sidePawn) &&
checkerboard.AllMoves.Last().Pawn.PawnType == PawnType.Pawn &&
checkerboard.AllMoves.Last().NewPawnPos == sidePawn.Position &&
checkerboard.IsOccupied(sidePawn.Position, out sidePosPawn) &&
!checkerboard.IsOccupied(finalPawnPos, out _));
}
public static Move GetMove(this Checkerboard checkerboard, Pawn pawn, Position newPos, Pawn takenPawn = null)
{
return(new Move {
MoveNumber = checkerboard.AllMoves.Count + 1,
Pawn = pawn,
PawnOriginPos = pawn.Position,
NewPawnPos = newPos,
TakenPawn = takenPawn,
});
}
public static Move GetCastlingMove(this Checkerboard checkerboard, Pawn pawn, Position newPos, Pawn CastlingRook = null, Position newCastlingRookPos = default)
{
return(new Move {
MoveNumber = checkerboard.AllMoves.Count + 1,
Pawn = pawn,
PawnOriginPos = pawn.Position,
NewPawnPos = newPos,
CastlingRook = CastlingRook,
CastlingRookNewPos = newCastlingRookPos,
});
}
//public override TileBase GetTileAtValue(float value)
//{
// Checkerboard noise = new Checkerboard();
// Logger.Manager.Log("hhhhhhhhhhhh " + noise.GetValue((int)GameMath.RandomChoice(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (int)GameMath.RandomChoice(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), 0));
// return TopTiles[(int)(noise.GetValue(value, value, 0) * TopTiles.Length)];
// return (TileBase)GameMath.RandomChoice(TopTiles);
//}
public override TileBase GetTileAtValue(float x, float y)
{
Checkerboard noise = new Checkerboard();
int value = (int)(noise.GetValue(x, y, 0) * (TopTiles.Length - 1));
if (value < 0)
{
value = 0;
}
return(TopTiles[value]);
}
private void bCreateShape_Click(object sender, RoutedEventArgs e)
{
shapeStackPanel.Children.Clear();
TextBlock text1 = new TextBlock();
// text1.Text = "The bad way :";
text1.Text = StringProvider.ShapeDemo_TheBadWay;
text1.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
shapeStackPanel.Children.Add(text1);
// The bad way...
Checkerboard checkerboard1 = new Checkerboard();
checkerboard1.Margin = new Thickness(5.0);
checkerboard1.Width = 400;
checkerboard1.Height = 160;
checkerboard1.Fill = new SolidColorBrush(Colors.Red);
checkerboard1.Stroke = new SolidColorBrush(Colors.Blue);
checkerboard1.StrokeThickness = 1.0;
checkerboard1.RowCount = 4;
checkerboard1.ColumnCount = 10;
checkerboard1.CellLength = 40;
shapeStackPanel.Children.Add(checkerboard1);
TextBlock text2 = new TextBlock();
// text2.Text = "The good way :";
text2.Text = StringProvider.ShapeDemo_TheGoodWay;
text2.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
shapeStackPanel.Children.Add(text2);
// The good way !
Checkerboard checkerboard2 = new Checkerboard();
checkerboard2.Margin = new Thickness(5.0);
checkerboard2.Width = 400;
checkerboard2.Height = 160;
checkerboard2.Fill = new SolidColorBrush(Colors.Orange);
checkerboard2.Stroke = new SolidColorBrush(Colors.Black);
checkerboard2.StrokeThickness = 1.0;
checkerboard2.BeginInit();
try
{
checkerboard2.RowCount = 4;
checkerboard2.ColumnCount = 10;
checkerboard2.CellLength = 40;
}
finally
{
checkerboard2.EndInitAndBuildContent();
}
shapeStackPanel.Children.Add(checkerboard2);
}
public IEnumerable <Move> GetMoves(Checkerboard checkerboard, Pawn pawn)
{
var pawnPos = pawn.Position;
var moveUpperRight = FindMove(checkerboard, pawn, pawnPos + new Position(1, 1));
var moveUpperLeft = FindMove(checkerboard, pawn, pawnPos - new Position(1, -1));
var moveLowerRight = FindMove(checkerboard, pawn, pawnPos + new Position(1, -1));
var moveLowerLeft = FindMove(checkerboard, pawn, pawnPos - new Position(1, 1));
var moveRight = FindMove(checkerboard, pawn, pawnPos + new Position(1, 0));
var moveLower = FindMove(checkerboard, pawn, pawnPos + new Position(0, -1));
var moveLeft = FindMove(checkerboard, pawn, pawnPos - new Position(1, 0));
var moveUpper = FindMove(checkerboard, pawn, pawnPos + new Position(0, 1));
if (moveUpperRight.HasValue)
{
yield return(moveUpperRight.Value);
}
if (moveUpperLeft.HasValue)
{
yield return(moveUpperLeft.Value);
}
if (moveLowerLeft.HasValue)
{
yield return(moveLowerLeft.Value);
}
if (moveLowerRight.HasValue)
{
yield return(moveLowerRight.Value);
}
if (moveRight.HasValue)
{
yield return(moveRight.Value);
}
if (moveLower.HasValue)
{
yield return(moveLower.Value);
}
if (moveLeft.HasValue)
{
yield return(moveLeft.Value);
}
if (moveUpper.HasValue)
{
yield return(moveUpper.Value);
}
//var castlingMoves = GetCastlingMoves(checkerboard, pawn);
//foreach (var move in castlingMoves) {
// yield return move;
//}
}
private void CheckerboardOnPieceMoved(Checkerboard sender, Vector2Int origin, Vector2Int target)
{
ClearSelection();
PieceView pieceView = grid[origin.x, origin.y].pieceView;
pieceView.MoveTo(TilespaceToLocalspace(target));
pieceView.gridPosition = target;
grid[target.x, target.y].pieceView = pieceView;
grid[origin.x, origin.y].pieceView = null;
}
public void On(NotifyGameStart message)
{
Assert.IsTrue(isEntered);
isPlaying = true;
checkerboard = message.checkerboard;
checkerboardView.Clear();
checkerboardView.SetCheckerboard(checkerboard);
bool isThisWhite = message.whitePlayerId == agent.playerInfo.id;
checkerboardView.SetOwnColor(isThisWhite ? Checkerboard.TileState.White : Checkerboard.TileState.Black);
checkerboardView.SetControlsEnabled(true);
}
public IEnumerable <Move> GetMoves(Checkerboard checkerboard, Pawn pawn)
{
var pawnPos = pawn.Position;
var moveUpperRight = FindMove(checkerboard, pawn, pawnPos + new Position(1, 2));
var moveUpperLeft = FindMove(checkerboard, pawn, pawnPos - new Position(1, -2));
var moveLowerRight = FindMove(checkerboard, pawn, pawnPos + new Position(1, -2));
var moveLowerLeft = FindMove(checkerboard, pawn, pawnPos - new Position(1, 2));
var moveRightUpper = FindMove(checkerboard, pawn, pawnPos + new Position(2, 1));
var moveRightLower = FindMove(checkerboard, pawn, pawnPos + new Position(2, -1));
var moveLeftUpper = FindMove(checkerboard, pawn, pawnPos - new Position(2, -1));
var moveLeftLower = FindMove(checkerboard, pawn, pawnPos - new Position(2, 1));
if (moveUpperRight.HasValue)
{
yield return(moveUpperRight.Value);
}
if (moveUpperLeft.HasValue)
{
yield return(moveUpperLeft.Value);
}
if (moveLowerLeft.HasValue)
{
yield return(moveLowerLeft.Value);
}
if (moveLowerRight.HasValue)
{
yield return(moveLowerRight.Value);
}
if (moveRightUpper.HasValue)
{
yield return(moveRightUpper.Value);
}
if (moveRightLower.HasValue)
{
yield return(moveRightLower.Value);
}
if (moveLeftUpper.HasValue)
{
yield return(moveLeftUpper.Value);
}
if (moveLeftLower.HasValue)
{
yield return(moveLeftLower.Value);
}
}
public void SetCheckerboard(Checkerboard newCheckerboard)
{
Assert.IsNotNull(newCheckerboard);
if (checkerboard != null && checkerboard != newCheckerboard)
{
Clear();
}
checkerboard = newCheckerboard;
InitializeGrid();
checkerboard.OnPieceAdded += CheckerboardOnPieceAdded;
checkerboard.OnPieceMoved += CheckerboardOnPieceMoved;
checkerboard.OnPieceRemoved += CheckerboardOnPieceRemoved;
checkerboard.OnMultiCapture += CheckerboardOnMultiCapture;
}
public void Clear()
{
if (checkerboard != null)
{
checkerboard.OnPieceAdded -= CheckerboardOnPieceAdded;
checkerboard.OnPieceMoved -= CheckerboardOnPieceMoved;
checkerboard.OnPieceRemoved -= CheckerboardOnPieceRemoved;
checkerboard.OnMultiCapture -= CheckerboardOnMultiCapture;
checkerboard = null;
}
DestroyAllChildren(tilesParent);
DestroyAllChildren(overlaysParent);
DestroyAllChildren(piecesParent);
grid = null;
ownColor = Checkerboard.TileState.White;
}
public IEnumerable <Move> GetTakes(Checkerboard checkerboard, Pawn pawn)
{
Position leftPos;
Position rightPos;
Position frontLeftPos;
Position frontRightPos;
int curPawnLetter = pawn.Position.Letter;
int curPawnDigit = pawn.Position.Digit;
if (pawn.PawnColor == PawnColor.White)
{
frontLeftPos = new Position((curPawnLetter - 1), curPawnDigit + 1);
frontRightPos = new Position((curPawnLetter + 1), curPawnDigit + 1);
leftPos = new Position((curPawnLetter - 1), curPawnDigit);
rightPos = new Position((curPawnLetter + 1), curPawnDigit);
}
else
{
frontLeftPos = new Position((curPawnLetter + 1), curPawnDigit - 1);
frontRightPos = new Position((curPawnLetter - 1), curPawnDigit - 1);
leftPos = new Position((curPawnLetter - 1), curPawnDigit);
rightPos = new Position((curPawnLetter + 1), curPawnDigit);
}
if (checkerboard.IsOccupied(leftPos, out Pawn oppositeLeftPawn) && CanTakeEnPassant(checkerboard, pawn, oppositeLeftPawn, frontLeftPos, out Pawn frontLeftPawn))
{
yield return(checkerboard.GetMove(pawn, frontLeftPos, frontLeftPawn));
}
if (checkerboard.IsOccupied(rightPos, out Pawn oppositeRightPawn) && CanTakeEnPassant(checkerboard, pawn, oppositeRightPawn, frontRightPos, out Pawn frontRightPawn))
{
yield return(checkerboard.GetMove(pawn, frontRightPos, frontRightPawn));
}
if (checkerboard.IsOccupied(frontLeftPos, out Pawn frontLeftPawn1) && pawn.AreOppositeColor(frontLeftPawn1))
{
yield return(checkerboard.GetMove(pawn, frontLeftPos, frontLeftPawn1));
}
if (checkerboard.IsOccupied(frontRightPos, out Pawn frontRightPawn1) && pawn.AreOppositeColor(frontRightPawn1))
{
yield return(checkerboard.GetMove(pawn, frontRightPos, frontRightPawn1));
}
}
public void On(MakeMove request)
{
if (!IsFromPlayersAtThisTable(request))
{
return;
}
if (!IsFromCorrectPlayer(request))
{
Debug.LogWarning("Request to move a piece came from the wrong player.");
SendAllAtTable(MakeServerChatMessage("Warning: Request to make invalid move."));
return;
}
if (!checkerboard.TryMakeMove(request.origin, request.target))
{
Debug.LogWarning("Request to make invalid move.");
SendAllAtTable(MakeServerChatMessage("Warning: Request to make invalid move."));
return;
}
AnnounceMove(request.origin, request.target);
Checkerboard.TileState victorColor = checkerboard.CheckVictory();
if (victorColor != Checkerboard.TileState.None)
{
ServerPlayer victor = victorColor == Checkerboard.TileState.White ? playerA : playerB;
SendAllAtTable(new NotifyVictory(victor.playerId));
SendAllAtTable(MakeServerChatMessage($"{victor.nickname} wins!"));
checkerboard = CheckersHelper.MakeDefaultCheckerboard();
StartNewGame();
AnnounceNewTurn(GetCurrentPlayer());
return;
}
currentPlayerIsB = checkerboard.currentPlayerColor == Checkerboard.TileState.Black;
// only change if not double capture
//currentPlayerIsB = !currentPlayerIsB;
AnnounceNewTurn(GetCurrentPlayer());
}
public static IEnumerable <Move> FindMovesAlongDirection(this Checkerboard checkerboard, Pawn pawn, Position delta)
{
var currPosition = pawn.Position + delta;
while (Checkerboard.Exists(currPosition))
{
if (checkerboard.IsOccupied(currPosition, out Pawn currPosPawn))
{
if (currPosPawn.AreOppositeColor(pawn))
{
yield return(checkerboard.GetMove(pawn, currPosition, currPosPawn));
}
break;
}
else if (checkerboard.IsEmptyButExists(currPosition))
{
yield return(checkerboard.GetMove(pawn, currPosition));
}
currPosition += delta;
}
}
public static Module <Color> Func()
{
var perlin = new Ibasa.Noise.Perlin(0);
var fbm = new Ibasa.Noise.Fbm(source: perlin,
octaves: 6, persistance: 0.5, frequency: 0.5,
lacunarity: 1.0);
var ridged = new Ibasa.Noise.RidgedMulti(source: perlin,
octaves: 6, frequency: 1.0, lacunarity: 2.0,
offset: 1.0, gain: 2.0, sharpness: 5.5);
var exp = new Ibasa.Noise.Exponent(fbm, 0.6);
var billow = new Ibasa.Noise.Billow(source: perlin);
var billowScale = new Ibasa.Noise.ScaleBias(billow, 0.35);
var mult = new Ibasa.Noise.Map <double, double, double>(exp, ridged, (d1, d2) => d1 * d2);
var multScale = new Ibasa.Noise.ScaleBias(mult, 4.0, -2.0);
var select = new Ibasa.Noise.Select(exp, billowScale, multScale, -1.0, 1.0, 0.75);
var check = new Checkerboard();
var scale = new Ibasa.Noise.ScalePoint <double>(select, 0.01f, 0.01f);
var rotate = new Ibasa.Noise.RotatePoint <double>(scale, Math.PI / 1.5);
var bias = new Ibasa.Noise.ScaleBias(rotate, 50.0, -25.0);
Ibasa.Noise.Module <Color> grey = new Map <double, Color>(bias, (d) => new Color(d, d, d));
return(grey);
}
public Checkerboard(Checkerboard checkerboard)
{
currentPlayerColor = checkerboard.currentPlayerColor;
size = checkerboard.size;
tiles = (TileState[, ])checkerboard.tiles.Clone();
}
static IEnumerable <Move> GetCastlingMoves(Checkerboard checkerboard, Pawn king)
{
if (checkerboard.AllMoves.Any(move => move.Pawn == king) || checkerboard.CheckIfCheck(checkerboard.CurrentColorToMove))
{
yield break;
}
var rookH = checkerboard.GetPawns(king.PawnColor).FirstOrDefault(p => p.PawnType == PawnType.Rook && p.Position.Letter == 7);
if (rookH != null &&
!checkerboard.AllMoves.Any(m => m.Pawn == rookH) &&
GetPositionsInBetween(king.PawnColor, false).Any(pos => checkerboard.GetPawn(pos.Letter, pos.Digit) == null) &&
!checkerboard.GetPawns(king.PawnColor.Opposite())
.Any(p => p.GetAvailableMoves(checkerboard)
.Any(m => (m.NewPawnPos.Digit == rookH.Position.Digit - 1 && m.NewPawnPos.Letter == rookH.Position.Letter) ||
(m.NewPawnPos.Digit == rookH.Position.Digit - 2 && m.NewPawnPos.Letter == rookH.Position.Letter))))
{
yield return(checkerboard.GetCastlingMove(king, new Position(6, king.PawnColor == PawnColor.White ? 1 : 8), rookH, new Position(5, king.PawnColor == PawnColor.White ? 1 : 8)));
}
var rookA = checkerboard.GetPawns(king.PawnColor).FirstOrDefault(p => p.PawnType == PawnType.Rook && p.Position.Letter == 0);
if (rookA != null &&
!checkerboard.AllMoves.Any(m => m.Pawn == rookA) &&
GetPositionsInBetween(king.PawnColor, true).Any(pos => checkerboard.GetPawn(pos.Letter, pos.Digit) == null) &&
!checkerboard.GetPawns(king.PawnColor.Opposite())
.Any(p => p.GetAvailableMoves(checkerboard)
.Any(m => m.NewPawnPos.Digit == rookH.Position.Digit + 1 && m.NewPawnPos.Letter == rookH.Position.Letter ||
(m.NewPawnPos.Digit == rookH.Position.Digit + 2 && m.NewPawnPos.Letter == rookH.Position.Letter) ||
(m.NewPawnPos.Digit == rookH.Position.Digit + 3 && m.NewPawnPos.Letter == rookH.Position.Letter))))
{
yield return(checkerboard.GetCastlingMove(king, new Position(2, king.PawnColor == PawnColor.White ? 1 : 8), rookH, new Position(4, king.PawnColor == PawnColor.White ? 1 : 8)));
}
IEnumerable <Position> GetPositionsInBetween(PawnColor pawnColor, bool smallCastle)
{
if (pawnColor == PawnColor.White && smallCastle)
{
yield return(new Position(5, 1));
yield return(new Position(6, 1));
}
else if (pawnColor == PawnColor.White)
{
yield return(new Position(1, 1));
yield return(new Position(2, 1));
yield return(new Position(3, 1));
}
else if (smallCastle)
{
yield return(new Position(5, 8));
yield return(new Position(6, 8));
}
else
{
yield return(new Position(1, 8));
yield return(new Position(2, 8));
yield return(new Position(3, 8));
}
}
}
