lucas/Shogi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch to Vector2

Browse Source
This commit is contained in:
Lucas Morgan
2021-02-26 17:11:08 -06:00
parent 640db4f4a2
commit 715b328ef5
9 changed files with 154 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
Benchmarking/Benchmarks.cs
View File

@@ -2,6 +2,7 @@
using BenchmarkDotNet.Running; using BenchmarkDotNet.Running;
using Gameboard.ShogiUI.BoardState; using Gameboard.ShogiUI.BoardState;
using System; using System;
using System.Numerics;
namespace Benchmarking namespace Benchmarking
{ {
@@ -14,25 +15,25 @@ namespace Benchmarking
moves = new[] moves = new[]
{ {
// P1 Rook // P1 Rook
new Move { From = new BoardVector(7, 1), To = new BoardVector(4, 1) }, new Move { From = new Vector2(7, 1), To = new Vector2(4, 1) },
// P2 Gold // P2 Gold
new Move { From = new BoardVector(3, 8), To = new BoardVector(2, 7) }, new Move { From = new Vector2(3, 8), To = new Vector2(2, 7) },
// P1 Pawn // P1 Pawn
new Move { From = new BoardVector(4, 2), To = new BoardVector(4, 3) }, new Move { From = new Vector2(4, 2), To = new Vector2(4, 3) },
// P2 other Gold // P2 other Gold
new Move { From = new BoardVector(5, 8), To = new BoardVector(6, 7) }, new Move { From = new Vector2(5, 8), To = new Vector2(6, 7) },
// P1 same Pawn // P1 same Pawn
new Move { From = new BoardVector(4, 3), To = new BoardVector(4, 4) }, new Move { From = new Vector2(4, 3), To = new Vector2(4, 4) },
// P2 Pawn // P2 Pawn
new Move { From = new BoardVector(4, 6), To = new BoardVector(4, 5) }, new Move { From = new Vector2(4, 6), To = new Vector2(4, 5) },
// P1 Pawn takes P2 Pawn // P1 Pawn takes P2 Pawn
new Move { From = new BoardVector(4, 4), To = new BoardVector(4, 5) }, new Move { From = new Vector2(4, 4), To = new Vector2(4, 5) },
// P2 King // P2 King
new Move { From = new BoardVector(4, 8), To = new BoardVector(4, 7) }, new Move { From = new Vector2(4, 8), To = new Vector2(4, 7) },
// P1 Pawn promotes // P1 Pawn promotes
new Move { From = new BoardVector(4, 5), To = new BoardVector(4, 6), IsPromotion = true }, new Move { From = new Vector2(4, 5), To = new Vector2(4, 6), IsPromotion = true },
// P2 King retreat // P2 King retreat
new Move { From = new BoardVector(4, 7), To = new BoardVector(4, 8) }, new Move { From = new Vector2(4, 7), To = new Vector2(4, 8) },
}; };
} }
@@ -42,7 +43,7 @@ namespace Benchmarking
var board = new ShogiBoard(); var board = new ShogiBoard();
foreach (var move in moves) foreach (var move in moves)
{ {
board.TryMove(move); board.Move(move);
} }
} }
@@ -62,8 +63,9 @@ namespace Benchmarking
{ {
public static void Main(string[] args) public static void Main(string[] args)
{ {
BenchmarkRunner.Run<Benchmarks>(); //BenchmarkRunner.Run<Benchmarks>();
Console.WriteLine("Done"); Console.WriteLine("Done");
} }
} }
} }

11
Gameboard.ShogiUI.BoardState/Array2D.cs
View File

@@ -1,6 +1,7 @@
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Numerics;
namespace Gameboard.ShogiUI.BoardState namespace Gameboard.ShogiUI.BoardState
{ {
@@ -24,6 +25,11 @@ namespace Gameboard.ShogiUI.BoardState
get => array[y * width + x]; get => array[y * width + x];
set => array[y * width + x] = value; set => array[y * width + x] = value;
} }
public T this[float x, float y]
{
get => array[(int)y * width + (int)x];
set => array[(int)y * width + (int)x] = value;
}
public void ForEach(ForEachDelegate callback) public void ForEach(ForEachDelegate callback)
{ {
@@ -48,15 +54,14 @@ namespace Gameboard.ShogiUI.BoardState
} }
} }
// TODO: Figure out a better return type, or make this class specific to ShogiBoard. public Vector2? IndexOf(Predicate<T> predicate)
public BoardVector IndexOf(Predicate<T> predicate)
{ {
for (var x = 0; x < width; x++) for (var x = 0; x < width; x++)
for (var y = 0; y < height; y++) for (var y = 0; y < height; y++)
{ {
if (this[x, y] != null && predicate(this[x, y])) if (this[x, y] != null && predicate(this[x, y]))
{ {
return new BoardVector(x, y); return new Vector2(x, y);
} }
} }
return null; return null;

65
Gameboard.ShogiUI.BoardState/BoardVector.cs
View File

@@ -1,21 +1,21 @@
using System.Diagnostics; using System.Numerics;
namespace Gameboard.ShogiUI.BoardState namespace Gameboard.ShogiUI.BoardState
{ {
/// <summary> /// <summary>
/// Provides normalized BoardVectors relative to player. /// Provides normalized Vector2s relative to player.
/// "Up" for player 1 is "Down" for player 2; that sort of thing. /// "Up" for player 1 is "Down" for player 2; that sort of thing.
/// </summary> /// </summary>
public class Direction public class Direction
{ {
private static readonly BoardVector PositiveX = new BoardVector(1, 0); private static readonly Vector2 PositiveX = new Vector2(1, 0);
private static readonly BoardVector NegativeX = new BoardVector(-1, 0); private static readonly Vector2 NegativeX = new Vector2(-1, 0);
private static readonly BoardVector PositiveY = new BoardVector(0, 1); private static readonly Vector2 PositiveY = new Vector2(0, 1);
private static readonly BoardVector NegativeY = new BoardVector(0, -1); private static readonly Vector2 NegativeY = new Vector2(0, -1);
private static readonly BoardVector PositiveYX = new BoardVector(1, 1); private static readonly Vector2 PositiveYX = new Vector2(1, 1);
private static readonly BoardVector NegativeYX = new BoardVector(-1, -1); private static readonly Vector2 NegativeYX = new Vector2(-1, -1);
private static readonly BoardVector NegativeYPositiveX = new BoardVector(1, -1); private static readonly Vector2 NegativeYPositiveX = new Vector2(1, -1);
private static readonly BoardVector PositiveYNegativeX = new BoardVector(-1, 1); private static readonly Vector2 PositiveYNegativeX = new Vector2(-1, 1);
private readonly WhichPlayer whichPlayer; private readonly WhichPlayer whichPlayer;
public Direction(WhichPlayer whichPlayer) public Direction(WhichPlayer whichPlayer)
@@ -23,40 +23,15 @@ namespace Gameboard.ShogiUI.BoardState
this.whichPlayer = whichPlayer; this.whichPlayer = whichPlayer;
} }
public BoardVector Up => whichPlayer == WhichPlayer.Player1 ? PositiveY : NegativeY; public Vector2 Up => whichPlayer == WhichPlayer.Player1 ? PositiveY : NegativeY;
public BoardVector Down => whichPlayer == WhichPlayer.Player1 ? NegativeY : PositiveY; public Vector2 Down => whichPlayer == WhichPlayer.Player1 ? NegativeY : PositiveY;
public BoardVector Left => whichPlayer == WhichPlayer.Player1 ? NegativeX : PositiveX; public Vector2 Left => whichPlayer == WhichPlayer.Player1 ? NegativeX : PositiveX;
public BoardVector Right => whichPlayer == WhichPlayer.Player1 ? PositiveX : NegativeX; public Vector2 Right => whichPlayer == WhichPlayer.Player1 ? PositiveX : NegativeX;
public BoardVector UpLeft => whichPlayer == WhichPlayer.Player1 ? PositiveYNegativeX : NegativeYPositiveX; public Vector2 UpLeft => whichPlayer == WhichPlayer.Player1 ? PositiveYNegativeX : NegativeYPositiveX;
public BoardVector UpRight => whichPlayer == WhichPlayer.Player1 ? PositiveYX : NegativeYX; public Vector2 UpRight => whichPlayer == WhichPlayer.Player1 ? PositiveYX : NegativeYX;
public BoardVector DownLeft => whichPlayer == WhichPlayer.Player1 ? NegativeYX : PositiveYX; public Vector2 DownLeft => whichPlayer == WhichPlayer.Player1 ? NegativeYX : PositiveYX;
public BoardVector DownRight => whichPlayer == WhichPlayer.Player1 ? NegativeYPositiveX : PositiveYNegativeX; public Vector2 DownRight => whichPlayer == WhichPlayer.Player1 ? NegativeYPositiveX : PositiveYNegativeX;
public BoardVector KnightLeft => whichPlayer == WhichPlayer.Player1 ? new BoardVector(-1, 2) : new BoardVector(1, -2); public Vector2 KnightLeft => whichPlayer == WhichPlayer.Player1 ? new Vector2(-1, 2) : new Vector2(1, -2);
public BoardVector KnightRight => whichPlayer == WhichPlayer.Player1 ? new BoardVector(1, 2) : new BoardVector(-1, -2); public Vector2 KnightRight => whichPlayer == WhichPlayer.Player1 ? new Vector2(1, 2) : new Vector2(-1, -2);
}
[DebuggerDisplay("[{X}, {Y}]")]
public class BoardVector
{
public int X { get; set; }
public int Y { get; set; }
public bool IsValidBoardPosition => X > -1 && X < 9 && Y > -1 && Y < 9;
public bool IsHand => X < 0 && Y < 0; // TODO: Find a better way to distinguish positions vs hand.
public BoardVector(int x, int y)
{
X = x;
Y = y;
}
public BoardVector Add(BoardVector other) => new BoardVector(X + other.X, Y + other.Y);
public override bool Equals(object obj) => (obj is BoardVector other) && other.X == X && other.Y == Y;
public override int GetHashCode()
{
// [0,3] should hash different than [3,0]
return X.GetHashCode() * 3 + Y.GetHashCode() * 5;
}
public static bool operator ==(BoardVector a, BoardVector b) => a.Equals(b);
public static bool operator !=(BoardVector a, BoardVector b) => !a.Equals(b);
} }
} }

8
Gameboard.ShogiUI.BoardState/Move.cs
View File

@@ -1,10 +1,12 @@
namespace Gameboard.ShogiUI.BoardState using System.Numerics;
namespace Gameboard.ShogiUI.BoardState
{ {
public class Move public class Move
{ {
public WhichPiece? PieceFromCaptured { get; set; } public WhichPiece? PieceFromCaptured { get; set; }
public BoardVector From { get; set; } public Vector2 From { get; set; }
public BoardVector To { get; set; } public Vector2 To { get; set; }
public bool IsPromotion { get; set; } public bool IsPromotion { get; set; }
} }
} }

135
Gameboard.ShogiUI.BoardState/ShogiBoard.cs
View File

@@ -12,7 +12,7 @@ namespace Gameboard.ShogiUI.BoardState
/// </summary> /// </summary>
public class ShogiBoard public class ShogiBoard
{ {
private delegate void MoveSetCallback(Piece piece, BoardVector position); private delegate void MoveSetCallback(Piece piece, Vector2 position);
private ShogiBoard validationBoard; private ShogiBoard validationBoard;
private Vector2 player1King; private Vector2 player1King;
private Vector2 player2King; private Vector2 player2King;
@@ -35,59 +35,31 @@ namespace Gameboard.ShogiUI.BoardState
player1King = new Vector2(4, 0); player1King = new Vector2(4, 0);
player2King = new Vector2(4, 8); player2King = new Vector2(4, 8);
} }
public ShogiBoard(IList<Move> moves) : this()
{
for (var i = 0; i < moves.Count; i++)
{
if (!TryMove(moves[i]))
{
throw new InvalidOperationException($"Unable to construct ShogiBoard with the given move at index {i}.");
}
}
}
public bool Move(Move move)
{
var otherPlayer = WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
var moveSuccess = TryMove(move);
if (!moveSuccess) return false;
// Evaluate check
InCheck = EvaluateCheck(otherPlayer) ? otherPlayer : null;
if (InCheck.HasValue)
{
//IsCheckmate = EvaluateCheckmate();
}
return true;
}
/// <summary> /// <summary>
/// Attempts a given move. Returns false if the move is illegal. /// Attempts a given move. Returns false if the move is illegal.
/// </summary> /// </summary>
//public bool TryMove2(Move move) private bool TryMove(Move move)
//{
// // Try making the move in a "throw away" board.
// if (validationBoard == null)
// {
// validationBoard = new ShogiBoard(MoveHistory);
// }
// var isValid = move.PieceFromCaptured.HasValue
// ? validationBoard.PlaceFromHand(move)
// : validationBoard.PlaceFromBoard(move);
// if (!isValid)
// {
// // Invalidate the "throw away" board.
// validationBoard = null;
// return false;
// }
// // Assert that this move does not put the moving player in check.
// if (validationBoard.EvaluateCheck(WhoseTurn)) return false;
// var otherPlayer = WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
// // The move is valid and legal; update board state.
// if (move.PieceFromCaptured.HasValue) PlaceFromHand(move);
// else PlaceFromBoard(move);
// // Evaluate check
// InCheck = EvaluateCheck(otherPlayer) ? otherPlayer : null;
// if (InCheck.HasValue)
// {
// //IsCheckmate = EvaluateCheckmate();
// }
// return true;
//}
public bool TryMove(Move move, bool shouldEvaluateCheck = true)
{ {
// Try making the move in a "throw away" board. // Try making the move in a "throw away" board.
if (validationBoard == null) if (validationBoard == null)
{ {
validationBoard = new ShogiBoard(MoveHistory); validationBoard = ConstructWithMoves(MoveHistory);
} }
var isValid = move.PieceFromCaptured.HasValue var isValid = move.PieceFromCaptured.HasValue
? validationBoard.PlaceFromHand(move) ? validationBoard.PlaceFromHand(move)
@@ -101,24 +73,11 @@ namespace Gameboard.ShogiUI.BoardState
// Assert that this move does not put the moving player in check. // Assert that this move does not put the moving player in check.
if (validationBoard.EvaluateCheck(WhoseTurn)) return false; if (validationBoard.EvaluateCheck(WhoseTurn)) return false;
var otherPlayer = WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
// The move is valid and legal; update board state. // The move is valid and legal; update board state.
if (move.PieceFromCaptured.HasValue) PlaceFromHand(move); if (move.PieceFromCaptured.HasValue) PlaceFromHand(move);
else PlaceFromBoard(move); else PlaceFromBoard(move);
// Evaluate check
if (shouldEvaluateCheck)
{
InCheck = EvaluateCheck(otherPlayer) ? otherPlayer : null;
if (InCheck.HasValue)
{
IsCheckmate = EvaluateCheckmate();
}
}
return true; return true;
} }
private bool EvaluateCheckmate() private bool EvaluateCheckmate()
{ {
if (!InCheck.HasValue) return false; if (!InCheck.HasValue) return false;
@@ -129,10 +88,10 @@ namespace Gameboard.ShogiUI.BoardState
{ {
if (!isCheckmate) return; // Short circuit if (!isCheckmate) return; // Short circuit
var from = new BoardVector(x, y); var from = new Vector2(x, y);
if (piece.Owner == InCheck) // Owned by the player in check... if (piece.Owner == InCheck) // Owned by the player in check...
{ {
var positionsToCheck = new List<BoardVector>(10); var positionsToCheck = new List<Vector2>(10);
IterateMoveSet(from, (innerPiece, position) => IterateMoveSet(from, (innerPiece, position) =>
{ {
if (innerPiece?.Owner != InCheck) positionsToCheck.Add(position); // Find possible moves... if (innerPiece?.Owner != InCheck) positionsToCheck.Add(position); // Find possible moves...
@@ -141,7 +100,8 @@ namespace Gameboard.ShogiUI.BoardState
// And evaluate if any move gets the player out of check. // And evaluate if any move gets the player out of check.
foreach (var position in positionsToCheck) foreach (var position in positionsToCheck)
{ {
var moveSuccess = validationBoard.TryMove(new Move { From = from, To = position }, false); if (validationBoard == null) validationBoard = ConstructWithMoves(MoveHistory);
var moveSuccess = validationBoard.TryMove(new Move { From = from, To = position });
if (moveSuccess) if (moveSuccess)
{ {
isCheckmate &= validationBoard.EvaluateCheck(InCheck.Value); isCheckmate &= validationBoard.EvaluateCheck(InCheck.Value);
@@ -277,8 +237,7 @@ namespace Gameboard.ShogiUI.BoardState
// ...that belongs to the opponent within range... // ...that belongs to the opponent within range...
if (piece.Owner != whichPlayer && (piece.IsRanged || Vector2.Distance(kingPosition, v) < 3)) if (piece.Owner != whichPlayer && (piece.IsRanged || Vector2.Distance(kingPosition, v) < 3))
{ {
Console.WriteLine($"Evaluating {piece.WhichPiece}"); IterateMoveSet(new Vector2(x, y), (threatenedPiece, position) =>
IterateMoveSet(new BoardVector(x, y), (threatenedPiece, position) =>
{ {
// ...and threatens the player's king. // ...and threatens the player's king.
inCheck |= inCheck |=
@@ -289,8 +248,7 @@ namespace Gameboard.ShogiUI.BoardState
}); });
return inCheck; return inCheck;
} }
private bool ValidateMoveAgainstMoveSet(Vector2 from, Vector2 to)
private bool ValidateMoveAgainstMoveSet(BoardVector from, BoardVector to)
{ {
var isValid = false; var isValid = false;
IterateMoveSet(from, (piece, position) => IterateMoveSet(from, (piece, position) =>
@@ -306,7 +264,7 @@ namespace Gameboard.ShogiUI.BoardState
/// <summary> /// <summary>
/// Iterate through the possible moves of a piece at a given position. /// Iterate through the possible moves of a piece at a given position.
/// </summary> /// </summary>
private void IterateMoveSet(BoardVector from, MoveSetCallback callback) private void IterateMoveSet(Vector2 from, MoveSetCallback callback)
{ {
// TODO: Make these are of the move To, so only possible moves towards the move To are iterated. // TODO: Make these are of the move To, so only possible moves towards the move To are iterated.
// Maybe separate functions? Sometimes I need to iterate the whole move-set, sometimes I need to iterate only the move-set towards the move To. // Maybe separate functions? Sometimes I need to iterate the whole move-set, sometimes I need to iterate only the move-set towards the move To.
@@ -339,7 +297,7 @@ namespace Gameboard.ShogiUI.BoardState
break; break;
} }
} }
private void IterateKingMoveSet(BoardVector from, MoveSetCallback callback) private void IterateKingMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner); var direction = new Direction(piece.Owner);
@@ -352,7 +310,7 @@ namespace Gameboard.ShogiUI.BoardState
BoardStep(from, direction.Left, callback); BoardStep(from, direction.Left, callback);
BoardStep(from, direction.Right, callback); BoardStep(from, direction.Right, callback);
} }
private void IterateGoldenGeneralMoveSet(BoardVector from, MoveSetCallback callback) private void IterateGoldenGeneralMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner); var direction = new Direction(piece.Owner);
@@ -363,7 +321,7 @@ namespace Gameboard.ShogiUI.BoardState
BoardStep(from, direction.Left, callback); BoardStep(from, direction.Left, callback);
BoardStep(from, direction.Right, callback); BoardStep(from, direction.Right, callback);
} }
private void IterateSilverGeneralMoveSet(BoardVector from, MoveSetCallback callback) private void IterateSilverGeneralMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner); var direction = new Direction(piece.Owner);
@@ -380,7 +338,7 @@ namespace Gameboard.ShogiUI.BoardState
BoardStep(from, direction.DownRight, callback); BoardStep(from, direction.DownRight, callback);
} }
} }
private void IterateBishopMoveSet(BoardVector from, MoveSetCallback callback) private void IterateBishopMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner); var direction = new Direction(piece.Owner);
@@ -396,7 +354,7 @@ namespace Gameboard.ShogiUI.BoardState
BoardStep(from, direction.Down, callback); BoardStep(from, direction.Down, callback);
} }
} }
private void IterateRookMoveSet(BoardVector from, MoveSetCallback callback) private void IterateRookMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner); var direction = new Direction(piece.Owner);
@@ -412,7 +370,7 @@ namespace Gameboard.ShogiUI.BoardState
BoardStep(from, direction.DownRight, callback); BoardStep(from, direction.DownRight, callback);
} }
} }
private void IterateKnightMoveSet(BoardVector from, MoveSetCallback callback) private void IterateKnightMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
if (piece.IsPromoted) if (piece.IsPromoted)
@@ -426,7 +384,7 @@ namespace Gameboard.ShogiUI.BoardState
BoardStep(from, direction.KnightRight, callback); BoardStep(from, direction.KnightRight, callback);
} }
} }
private void IterateLanceMoveSet(BoardVector from, MoveSetCallback callback) private void IterateLanceMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
if (piece.IsPromoted) if (piece.IsPromoted)
@@ -439,7 +397,7 @@ namespace Gameboard.ShogiUI.BoardState
BoardWalk(from, direction.Up, callback); BoardWalk(from, direction.Up, callback);
} }
} }
private void IteratePawnMoveSet(BoardVector from, MoveSetCallback callback) private void IteratePawnMoveSet(Vector2 from, MoveSetCallback callback)
{ {
var piece = Board[from.X, from.Y]; var piece = Board[from.X, from.Y];
if (piece?.WhichPiece == WhichPiece.Pawn) if (piece?.WhichPiece == WhichPiece.Pawn)
@@ -459,15 +417,15 @@ namespace Gameboard.ShogiUI.BoardState
/// Useful for iterating the board for pieces that move many spaces. /// Useful for iterating the board for pieces that move many spaces.
/// </summary> /// </summary>
/// <param name="callback">A function that returns true if walking should continue.</param> /// <param name="callback">A function that returns true if walking should continue.</param>
private void BoardWalk(BoardVector from, BoardVector direction, MoveSetCallback callback) private void BoardWalk(Vector2 from, Vector2 direction, MoveSetCallback callback)
{ {
var foundAnotherPiece = false; var foundAnotherPiece = false;
var to = from.Add(direction); var to = Vector2.Add(from, direction);
while (to.IsValidBoardPosition && !foundAnotherPiece) while (to.X >= 0 && to.X < 9 && to.Y >= 0 && to.Y < 9 && !foundAnotherPiece)
{ {
var piece = Board[to.X, to.Y]; var piece = Board[to.X, to.Y];
callback(piece, to); callback(piece, to);
to = to.Add(direction); to = Vector2.Add(to, direction);
foundAnotherPiece = piece != null; foundAnotherPiece = piece != null;
} }
} }
@@ -475,10 +433,10 @@ namespace Gameboard.ShogiUI.BoardState
/// <summary> /// <summary>
/// Useful for iterating the board for pieces that move only one space. /// Useful for iterating the board for pieces that move only one space.
/// </summary> /// </summary>
private void BoardStep(BoardVector from, BoardVector direction, MoveSetCallback callback) private void BoardStep(Vector2 from, Vector2 direction, MoveSetCallback callback)
{ {
var to = from.Add(direction); var to = Vector2.Add(from, direction);
if (to.IsValidBoardPosition) if (to.X >= 0 && to.X < 9 && to.Y >= 0 && to.Y < 9)
{ {
callback(Board[to.X, to.Y], to); callback(Board[to.X, to.Y], to);
} }
@@ -540,5 +498,18 @@ namespace Gameboard.ShogiUI.BoardState
ResetRearRow(WhichPlayer.Player2); ResetRearRow(WhichPlayer.Player2);
} }
#endregion #endregion
public static ShogiBoard ConstructWithMoves(IList<Move> moves)
{
var s = new ShogiBoard();
for (var i = 0; i < moves.Count; i++)
{
if (!s.Move(moves[i]))
{
throw new InvalidOperationException($"Unable to construct ShogiBoard with the given move at index {i}.");
}
}
return s;
}
} }
} }

2
Gameboard.ShogiUI.Sockets/Managers/ClientActionHandlers/LoadGameHandler.cs
View File

@@ -52,7 +52,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
communicationManager.SubscribeToGame(sessionModel, userName); communicationManager.SubscribeToGame(sessionModel, userName);
var boardMoves = moveModels.Select(_ => _.ToBoardModel()).ToList(); var boardMoves = moveModels.Select(_ => _.ToBoardModel()).ToList();
boardManager.Add(getGameResponse.Session.Name, new ShogiBoard(boardMoves)); boardManager.Add(getGameResponse.Session.Name, ShogiBoard.ConstructWithMoves(boardMoves));
var response = new LoadGameResponse(ClientAction.LoadGame) var response = new LoadGameResponse(ClientAction.LoadGame)
{ {

5
Gameboard.ShogiUI.Sockets/Models/Move.cs
View File

@@ -1,6 +1,7 @@
using Gameboard.ShogiUI.BoardState; using Gameboard.ShogiUI.BoardState;
using Microsoft.FSharp.Core; using Microsoft.FSharp.Core;
using System; using System;
using System.Numerics;
using ShogiApi = Gameboard.Shogi.Api.ServiceModels.Types; using ShogiApi = Gameboard.Shogi.Api.ServiceModels.Types;
namespace Gameboard.ShogiUI.Sockets.Models namespace Gameboard.ShogiUI.Sockets.Models
@@ -77,10 +78,10 @@ namespace Gameboard.ShogiUI.Sockets.Models
{ {
return new BoardState.Move return new BoardState.Move
{ {
From = new BoardVector(From.X, From.Y), From = new Vector2(From.X, From.Y),
IsPromotion = IsPromotion, IsPromotion = IsPromotion,
PieceFromCaptured = Enum.TryParse<WhichPiece>(PieceFromCaptured, out var whichPiece) ? whichPiece : null, PieceFromCaptured = Enum.TryParse<WhichPiece>(PieceFromCaptured, out var whichPiece) ? whichPiece : null,
To = new BoardVector(To.X, To.Y) To = new Vector2(To.X, To.Y)
}; };
} }
} }

26
Gameboard.ShogiUI.UnitTests/BoardState/BoardVectorShould.cs
View File

@@ -1,26 +0,0 @@
using FluentAssertions;
using Gameboard.ShogiUI.BoardState;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Gameboard.ShogiUI.UnitTests.BoardState
{
[TestClass]
public class BoardVectorShould
{
[TestMethod]
public void BeEqualWhenPropertiesAreEqual()
{
var a = new BoardVector(3, 2);
var b = new BoardVector(3, 2);
a.Should().Be(b);
a.GetHashCode().Should().Be(b.GetHashCode());
(a == b).Should().BeTrue();
// Properties should not be transitively equal.
b = new BoardVector(2, 3);
a.Should().NotBe(b);
a.GetHashCode().Should().NotBe(b.GetHashCode());
(a == b).Should().BeFalse();
}
}
}

95
Gameboard.ShogiUI.UnitTests/BoardState/ShogiBoardShould.cs
View File

@@ -1,8 +1,9 @@
using FluentAssertions; using FluentAssertions;
using Gameboard.ShogiUI.BoardState; using Gameboard.ShogiUI.BoardState;
using Microsoft.VisualStudio.TestTools.UnitTesting; using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Linq; using System.Linq;
using System.Numerics;
namespace Gameboard.ShogiUI.UnitTests.BoardState namespace Gameboard.ShogiUI.UnitTests.BoardState
{ {
[TestClass] [TestClass]
@@ -70,11 +71,11 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
new Move new Move
{ {
// Pawn // Pawn
From = new BoardVector(0, 2), From = new Vector2(0, 2),
To = new BoardVector(0, 3) To = new Vector2(0, 3)
} }
}; };
var shogi = new ShogiBoard(moves); var shogi = ShogiBoard.ConstructWithMoves(moves);
shogi.Board[0, 2].Should().BeNull(); shogi.Board[0, 2].Should().BeNull();
shogi.Board[0, 3].WhichPiece.Should().Be(WhichPiece.Pawn); shogi.Board[0, 3].WhichPiece.Should().Be(WhichPiece.Pawn);
} }
@@ -86,7 +87,7 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var shogi = new ShogiBoard(); var shogi = new ShogiBoard();
// Act - P1 "moves" pawn to the position it already exists at. // Act - P1 "moves" pawn to the position it already exists at.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(0, 2), To = new BoardVector(0, 2) }); var moveSuccess = shogi.Move(new Move { From = new Vector2(0, 2), To = new Vector2(0, 2) });
// Assert // Assert
moveSuccess.Should().BeFalse(); moveSuccess.Should().BeFalse();
@@ -99,12 +100,12 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var invalidLanceMove = new Move var invalidLanceMove = new Move
{ {
// Lance moving adjacent // Lance moving adjacent
From = new BoardVector(0, 0), From = new Vector2(0, 0),
To = new BoardVector(1, 5) To = new Vector2(1, 5)
}; };
var shogi = new ShogiBoard(); var shogi = new ShogiBoard();
var moveSuccess = shogi.TryMove(invalidLanceMove); var moveSuccess = shogi.Move(invalidLanceMove);
moveSuccess.Should().BeFalse(); moveSuccess.Should().BeFalse();
// Assert the Lance has not actually moved. // Assert the Lance has not actually moved.
@@ -118,7 +119,7 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var shogi = new ShogiBoard(); var shogi = new ShogiBoard();
// Act - Move Player2 Pawn when it's Player1 turn. // Act - Move Player2 Pawn when it's Player1 turn.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(8, 6), To = new BoardVector(8, 5) }); var moveSuccess = shogi.Move(new Move { From = new Vector2(8, 6), To = new Vector2(8, 5) });
// Assert // Assert
moveSuccess.Should().BeFalse(); moveSuccess.Should().BeFalse();
@@ -132,12 +133,12 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var invalidLanceMove = new Move var invalidLanceMove = new Move
{ {
// Lance moving through the pawn before it. // Lance moving through the pawn before it.
From = new BoardVector(0, 0), From = new Vector2(0, 0),
To = new BoardVector(0, 5) To = new Vector2(0, 5)
}; };
var shogi = new ShogiBoard(); var shogi = new ShogiBoard();
var moveSuccess = shogi.TryMove(invalidLanceMove); var moveSuccess = shogi.Move(invalidLanceMove);
moveSuccess.Should().BeFalse(); moveSuccess.Should().BeFalse();
// Assert the Lance has not actually moved. // Assert the Lance has not actually moved.
@@ -150,12 +151,12 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var invalidKnightMove = new Move var invalidKnightMove = new Move
{ {
// Knight capturing allied Pawn // Knight capturing allied Pawn
From = new BoardVector(1, 0), From = new Vector2(1, 0),
To = new BoardVector(0, 2) To = new Vector2(0, 2)
}; };
var shogi = new ShogiBoard(); var shogi = new ShogiBoard();
var moveSuccess = shogi.TryMove(invalidKnightMove); var moveSuccess = shogi.Move(invalidKnightMove);
moveSuccess.Should().BeFalse(); moveSuccess.Should().BeFalse();
// Assert the Knight has not actually moved or captured. // Assert the Knight has not actually moved or captured.
@@ -170,20 +171,24 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var moves = new[] var moves = new[]
{ {
// P1 Pawn // P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) }, new Move { From = new Vector2(2, 2), To = new Vector2(2, 3) },
// P2 Pawn // P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) }, new Move { From = new Vector2(6, 6), To = new Vector2(6, 5) },
// P1 Bishop puts P2 in check // P1 Bishop puts P2 in check
new Move { From = new BoardVector(1, 1), To = new BoardVector(6, 6) } new Move { From = new Vector2(1, 1), To = new Vector2(6, 6) }
}; };
var shogi = new ShogiBoard(moves); var shogi = ShogiBoard.ConstructWithMoves(moves);
//foreach(var m in moves)
//{
// shogi.Move(m);
//}
// Prerequisit // Prerequisit
shogi.InCheck.Should().Be(WhichPlayer.Player2); shogi.InCheck.Should().Be(WhichPlayer.Player2);
// Act - P2 moves Lance while remaining in check. // Act - P2 moves Lance while remaining in check.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(8, 8), To = new BoardVector(8, 7) }); var moveSuccess = shogi.Move(new Move { From = new Vector2(8, 8), To = new Vector2(8, 7) });
// Assert // Assert
moveSuccess.Should().BeFalse(); moveSuccess.Should().BeFalse();
@@ -199,15 +204,15 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var moves = new[] var moves = new[]
{ {
// P1 Pawn // P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) }, new Move { From = new Vector2(2, 2), To = new Vector2(2, 3) },
// P2 Pawn // P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) }, new Move { From = new Vector2(6, 6), To = new Vector2(6, 5) },
}; };
var shogi = new ShogiBoard(moves); var shogi = ShogiBoard.ConstructWithMoves(moves);
// Act - P1 Bishop, check // Act - P1 Bishop, check
shogi.TryMove(new Move { From = new BoardVector(1, 1), To = new BoardVector(6, 6) }); shogi.Move(new Move { From = new Vector2(1, 1), To = new Vector2(6, 6) });
// Assert // Assert
shogi.InCheck.Should().Be(WhichPlayer.Player2); shogi.InCheck.Should().Be(WhichPlayer.Player2);
@@ -220,14 +225,14 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var moves = new[] var moves = new[]
{ {
// P1 Pawn // P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) }, new Move { From = new Vector2(2, 2), To = new Vector2(2, 3) },
// P2 Pawn // P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) } new Move { From = new Vector2(6, 6), To = new Vector2(6, 5) }
}; };
var shogi = new ShogiBoard(moves); var shogi = ShogiBoard.ConstructWithMoves(moves);
// Act - P1 Bishop captures P2 Bishop // Act - P1 Bishop captures P2 Bishop
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(1, 1), To = new BoardVector(7, 7) }); var moveSuccess = shogi.Move(new Move { From = new Vector2(1, 1), To = new Vector2(7, 7) });
// Assert // Assert
moveSuccess.Should().BeTrue(); moveSuccess.Should().BeTrue();
@@ -244,7 +249,7 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
// Act - P2 Silver captures P1 Bishop // Act - P2 Silver captures P1 Bishop
moveSuccess = shogi.TryMove(new Move { From = new BoardVector(6, 8), To = new BoardVector(7, 7) }); moveSuccess = shogi.Move(new Move { From = new Vector2(6, 8), To = new Vector2(7, 7) });
// Assert // Assert
moveSuccess.Should().BeTrue(); moveSuccess.Should().BeTrue();
@@ -266,14 +271,14 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var moves = new[] var moves = new[]
{ {
// P1 Pawn // P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) }, new Move { From = new Vector2(2, 2), To = new Vector2(2, 3) },
// P2 Pawn // P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) } new Move { From = new Vector2(6, 6), To = new Vector2(6, 5) }
}; };
var shogi = new ShogiBoard(moves); var shogi = ShogiBoard.ConstructWithMoves(moves);
// Act - P1 moves across promote threshold. // Act - P1 moves across promote threshold.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(1, 1), To = new BoardVector(6, 6), IsPromotion = true }); var moveSuccess = shogi.Move(new Move { From = new Vector2(1, 1), To = new Vector2(6, 6), IsPromotion = true });
// Assert // Assert
moveSuccess.Should().BeTrue(); moveSuccess.Should().BeTrue();
@@ -288,30 +293,30 @@ namespace Gameboard.ShogiUI.UnitTests.BoardState
var moves = new[] var moves = new[]
{ {
// P1 Rook // P1 Rook
new Move { From = new BoardVector(7, 1), To = new BoardVector(4, 1) }, new Move { From = new Vector2(7, 1), To = new Vector2(4, 1) },
// P2 Gold // P2 Gold
new Move { From = new BoardVector(3, 8), To = new BoardVector(2, 7) }, new Move { From = new Vector2(3, 8), To = new Vector2(2, 7) },
// P1 Pawn // P1 Pawn
new Move { From = new BoardVector(4, 2), To = new BoardVector(4, 3) }, new Move { From = new Vector2(4, 2), To = new Vector2(4, 3) },
// P2 other Gold // P2 other Gold
new Move { From = new BoardVector(5, 8), To = new BoardVector(6, 7) }, new Move { From = new Vector2(5, 8), To = new Vector2(6, 7) },
// P1 same Pawn // P1 same Pawn
new Move { From = new BoardVector(4, 3), To = new BoardVector(4, 4) }, new Move { From = new Vector2(4, 3), To = new Vector2(4, 4) },
// P2 Pawn // P2 Pawn
new Move { From = new BoardVector(4, 6), To = new BoardVector(4, 5) }, new Move { From = new Vector2(4, 6), To = new Vector2(4, 5) },
// P1 Pawn takes P2 Pawn // P1 Pawn takes P2 Pawn
new Move { From = new BoardVector(4, 4), To = new BoardVector(4, 5) }, new Move { From = new Vector2(4, 4), To = new Vector2(4, 5) },
// P2 King // P2 King
new Move { From = new BoardVector(4, 8), To = new BoardVector(4, 7) }, new Move { From = new Vector2(4, 8), To = new Vector2(4, 7) },
// P1 Pawn promotes // P1 Pawn promotes
new Move { From = new BoardVector(4, 5), To = new BoardVector(4, 6), IsPromotion = true }, new Move { From = new Vector2(4, 5), To = new Vector2(4, 6), IsPromotion = true },
// P2 King retreat // P2 King retreat
new Move { From = new BoardVector(4, 7), To = new BoardVector(4, 8) }, new Move { From = new Vector2(4, 7), To = new Vector2(4, 8) },
}; };
var shogi = new ShogiBoard(moves); var shogi = ShogiBoard.ConstructWithMoves(moves);
// Act - P1 Pawn wins by checkmate. // Act - P1 Pawn wins by checkmate.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(4, 6), To = new BoardVector(4, 7) }); var moveSuccess = shogi.Move(new Move { From = new Vector2(4, 6), To = new Vector2(4, 7) });
// Assert // Assert
moveSuccess.Should().BeTrue(); moveSuccess.Should().BeTrue();