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

checkpoint

Browse Source
This commit is contained in:
Lucas Morgan
2021-02-23 18:03:23 -06:00
parent 8d79c75616
commit f644795cd3
38 changed files with 1451 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -52,3 +52,4 @@ Thumbs.db
#Luke
bin
obj
*.user

16
Benchmarking/Benchmarking.csproj Normal file
View File

@@ -0,0 +1,16 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net5.0</TargetFramework>
<OutputType>Exe</OutputType>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Gameboard.ShogiUI.BoardState\Gameboard.ShogiUI.BoardState.csproj" />
</ItemGroup>
</Project>

58
Benchmarking/Benchmarks.cs Normal file
View File

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

29
Gameboard.ShogiUI.BoardState/Array2D.cs Normal file
View File

@@ -0,0 +1,29 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Gameboard.ShogiUI.BoardState
{
public class Array2D<T> : IEnumerable
{
private readonly T[] array;
private readonly int width;
public Array2D(int width, int height)
{
this.width = width;
array = new T[width * height];
}
public T this[int x, int y]
{
get => array[y * width + x];
set => array[y * width + x] = value;
}
IEnumerator IEnumerable.GetEnumerator() => array.GetEnumerator();
}
}

62
Gameboard.ShogiUI.BoardState/BoardVector.cs Normal file
View File

@@ -0,0 +1,62 @@
using System.Diagnostics;
namespace Gameboard.ShogiUI.BoardState
{
/// <summary>
/// Provides normalized BoardVectors relative to player.
/// "Up" for player 1 is "Down" for player 2; that sort of thing.
/// </summary>
public class Direction
{
private static readonly BoardVector PositiveX = new BoardVector(1, 0);
private static readonly BoardVector NegativeX = new BoardVector(-1, 0);
private static readonly BoardVector PositiveY = new BoardVector(0, 1);
private static readonly BoardVector NegativeY = new BoardVector(0, -1);
private static readonly BoardVector PositiveYX = new BoardVector(1, 1);
private static readonly BoardVector NegativeYX = new BoardVector(-1, -1);
private static readonly BoardVector NegativeYPositiveX = new BoardVector(1, -1);
private static readonly BoardVector PositiveYNegativeX = new BoardVector(-1, 1);
private readonly WhichPlayer whichPlayer;
public Direction(WhichPlayer whichPlayer)
{
this.whichPlayer = whichPlayer;
}
public BoardVector Up => whichPlayer == WhichPlayer.Player1 ? PositiveY : NegativeY;
public BoardVector Down => whichPlayer == WhichPlayer.Player1 ? NegativeY : PositiveY;
public BoardVector Left => whichPlayer == WhichPlayer.Player1 ? NegativeX : PositiveX;
public BoardVector Right => whichPlayer == WhichPlayer.Player1 ? PositiveX : NegativeX;
public BoardVector UpLeft => whichPlayer == WhichPlayer.Player1 ? PositiveYNegativeX : NegativeYPositiveX;
public BoardVector UpRight => whichPlayer == WhichPlayer.Player1 ? PositiveYX : NegativeYX;
public BoardVector DownLeft => whichPlayer == WhichPlayer.Player1 ? NegativeYX : PositiveYX;
public BoardVector DownRight => whichPlayer == WhichPlayer.Player1 ? NegativeYPositiveX : PositiveYNegativeX;
public BoardVector KnightLeft => whichPlayer == WhichPlayer.Player1 ? new BoardVector(-1, 2) : new BoardVector(1, -2);
public BoardVector KnightRight => whichPlayer == WhichPlayer.Player1 ? new BoardVector(1, 2) : new BoardVector(-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);
}
}

19
Gameboard.ShogiUI.BoardState/Extensions.cs Normal file
View File

@@ -0,0 +1,19 @@
using System;
namespace Gameboard.ShogiUI.BoardState
{
public static class Extensions
{
public static void ForEachNotNull(this Piece[,] array, Action<Piece, int, int> action)
{
for (var x = 0; x < array.GetLength(0); x++)
for (var y = 0; y < array.GetLength(1); y++)
{
var piece = array[x, y];
if (piece != null)
{
action(piece, x, y);
}
}
}
}
}

7
Gameboard.ShogiUI.BoardState/Gameboard.ShogiUI.BoardState.csproj Normal file
View File

@@ -0,0 +1,7 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net5.0</TargetFramework>
</PropertyGroup>
</Project>

10
Gameboard.ShogiUI.BoardState/Move.cs Normal file
View File

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

53
Gameboard.ShogiUI.BoardState/Piece.cs Normal file
View File

@@ -0,0 +1,53 @@
using System.Diagnostics;
namespace Gameboard.ShogiUI.BoardState
{
[DebuggerDisplay("{WhichPiece} {Owner}")]
public class Piece
{
public WhichPiece WhichPiece { get; }
public WhichPlayer Owner { get; private set; }
public bool IsPromoted { get; private set; }
public Piece(WhichPiece piece, WhichPlayer owner)
{
WhichPiece = piece;
Owner = owner;
IsPromoted = false;
}
public bool CanPromote => !IsPromoted
&& WhichPiece != WhichPiece.King
&& WhichPiece != WhichPiece.GoldenGeneral;
public string ShortName => WhichPiece switch
{
WhichPiece.King => " K ",
WhichPiece.GoldenGeneral => " G ",
WhichPiece.SilverGeneral => IsPromoted ? "^S^" : " S ",
WhichPiece.Bishop => IsPromoted ? "^B^" : " B ",
WhichPiece.Rook => IsPromoted ? "^R^" : " R ",
WhichPiece.Knight => IsPromoted ? "^k^" : " k ",
WhichPiece.Lance => IsPromoted ? "^L^" : " L ",
WhichPiece.Pawn => IsPromoted ? "^P^" : " P ",
_ => " ? ",
};
public void ToggleOwnership()
{
Owner = Owner == WhichPlayer.Player1
? WhichPlayer.Player2
: WhichPlayer.Player1;
}
public void Promote() => IsPromoted = true;
public void Demote() => IsPromoted = false;
public void Capture()
{
ToggleOwnership();
Demote();
}
}
}

35
Gameboard.ShogiUI.BoardState/Position.cs Normal file
View File

@@ -0,0 +1,35 @@
using System;
namespace Gameboard.ShogiUI.BoardState
{
public class Position
{
private int x;
private int y;
public int X
{
get => x;
set {
if (value > 8 || value < 0) throw new ArgumentOutOfRangeException();
x = value;
}
}
public int Y
{
get => y;
set
{
if (value > 8 || value < 0) throw new ArgumentOutOfRangeException();
y = value;
}
}
public Position(int x, int y)
{
X = x;
Y = y;
}
}
}

522
Gameboard.ShogiUI.BoardState/ShogiBoard.cs Normal file
View File

@@ -0,0 +1,522 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Gameboard.ShogiUI.BoardState
{
/// <summary>
/// Facilitates Shogi board state transitions, cognisant of Shogi rules.
/// The board is always from Player1's perspective.
/// [0,0] is the lower-left position, [8,8] is the higher-right position
/// </summary>
public class ShogiBoard
{
private delegate void MoveSetCallback(Piece piece, BoardVector position);
private ShogiBoard validationBoard;
public IReadOnlyDictionary<WhichPlayer, List<Piece>> Hands { get; }
public Piece[,] Board { get; }
public List<Move> MoveHistory { get; }
public WhichPlayer WhoseTurn => MoveHistory.Count % 2 == 0 ? WhichPlayer.Player1 : WhichPlayer.Player2;
public WhichPlayer? InCheck { get; private set; }
public bool IsCheckmate { get; private set; }
public ShogiBoard()
{
Board = new Piece[9, 9];
MoveHistory = new List<Move>(20);
Hands = new Dictionary<WhichPlayer, List<Piece>> {
{ WhichPlayer.Player1, new List<Piece>()},
{ WhichPlayer.Player2, new List<Piece>()},
};
InitializeBoardState();
}
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}.");
}
}
}
/// <summary>
/// Attempts a given move. Returns false if the move is illegal.
/// </summary>
public 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;
}
private bool EvaluateCheckmate()
{
if (!InCheck.HasValue) return false;
// Assume true and try to disprove.
var isCheckmate = true;
Board.ForEachNotNull((piece, x, y) => // For each piece...
{
if (!isCheckmate) return; // Short circuit
var from = new BoardVector(x, y);
if (piece.Owner == InCheck) // Owned by the player in check...
{
var positionsToCheck = new List<BoardVector>(10);
IterateMoveSet(from, (innerPiece, position) =>
{
if (innerPiece?.Owner != InCheck) positionsToCheck.Add(position); // Find possible moves...
});
// And evaluate if any move gets the player out of check.
foreach (var position in positionsToCheck)
{
var moveSuccess = validationBoard.TryMove(new Move { From = from, To = position });
if (moveSuccess)
{
Console.WriteLine($"Not check mate");
isCheckmate &= validationBoard.EvaluateCheck(InCheck.Value);
validationBoard = null;
}
}
}
});
return isCheckmate;
}
/// <returns>True if the move was successful.</returns>
private bool PlaceFromHand(Move move)
{
if (move.PieceFromCaptured.HasValue == false) return false; //Invalid move
var index = Hands[WhoseTurn].FindIndex(p => p.WhichPiece == move.PieceFromCaptured);
if (index < 0) return false; // Invalid move
if (Board[move.To.X, move.To.Y] != null) return false; // Invalid move; cannot capture while playing from the hand.
var minimumY = 0;
switch (move.PieceFromCaptured.Value)
{
case WhichPiece.Knight:
// Knight cannot be placed onto the farthest two ranks from the hand.
minimumY = WhoseTurn == WhichPlayer.Player1 ? 2 : 6;
break;
case WhichPiece.Lance:
case WhichPiece.Pawn:
// Lance and Pawn cannot be placed onto the farthest rank from the hand.
minimumY = WhoseTurn == WhichPlayer.Player1 ? 1 : 7;
break;
}
if (WhoseTurn == WhichPlayer.Player1 && move.To.Y < minimumY) return false;
if (WhoseTurn == WhichPlayer.Player2 && move.To.Y > minimumY) return false;
// Mutate the board.
Board[move.To.X, move.To.Y] = Hands[WhoseTurn][index];
Hands[WhoseTurn].RemoveAt(index);
return true;
}
/// <returns>True if the move was successful.</returns>
private bool PlaceFromBoard(Move move)
{
var fromPiece = Board[move.From.X, move.From.Y];
if (fromPiece == null) return false; // Invalid move
if (fromPiece.Owner != WhoseTurn) return false; // Invalid move; cannot move other players pieces.
if (ValidateMoveAgainstMoveSet(move) == false) return false; // Invalid move; move not part of move-set.
var captured = Board[move.To.X, move.To.Y];
if (captured != null)
{
if (captured.Owner == WhoseTurn) return false; // Invalid move; cannot capture your own piece.
captured.Capture();
Hands[captured.Owner].Add(captured);
}
//Mutate the board.
if (move.IsPromotion)
{
if (WhoseTurn == WhichPlayer.Player1 && (move.To.Y > 5 || move.From.Y > 5))
{
fromPiece.Promote();
}
else if (WhoseTurn == WhichPlayer.Player2 && (move.To.Y < 3 || move.From.Y < 3))
{
fromPiece.Promote();
}
}
Board[move.To.X, move.To.Y] = fromPiece;
Board[move.From.X, move.From.Y] = null;
MoveHistory.Add(move);
return true;
}
public void PrintStateAsAscii()
{
var builder = new StringBuilder();
builder.Append(" Player 2");
builder.AppendLine();
for (var y = 8; y > -1; y--)
{
builder.Append("- ");
for (var x = 0; x < 8; x++) builder.Append("- - ");
builder.Append("- -");
builder.AppendLine();
builder.Append('|');
for (var x = 0; x < 9; x++)
{
var piece = Board[x, y];
if (piece == null)
{
builder.Append(" ");
}
else
{
builder.AppendFormat("{0}", piece.ShortName);
}
builder.Append('|');
}
builder.AppendLine();
}
builder.Append("- ");
for (var x = 0; x < 8; x++) builder.Append("- - ");
builder.Append("- -");
builder.AppendLine();
builder.Append(" Player 1");
Console.WriteLine(builder.ToString());
}
#region Rules Validation
/// <summary>
/// Evaluate if a player is in check given the current board state.
/// </summary>
private bool EvaluateCheck(WhichPlayer whichPlayer)
{
var inCheck = false;
// Iterate every board piece...
Board.ForEachNotNull((piece, x, y) =>
{
// ...that belongs to the opponent...
if (piece.Owner != whichPlayer)
{
IterateMoveSet(new BoardVector(x, y), (threatenedPiece, position) =>
{
// ...and threatens the player's king.
inCheck |=
threatenedPiece?.WhichPiece == WhichPiece.King
&& threatenedPiece?.Owner == whichPlayer;
});
}
});
return inCheck;
}
private bool EvaluateCheck2(WhichPlayer whichPlayer)
{
var inCheck = false;
MoveSetCallback checkKingThreat = (piece, position) =>
{
inCheck |=
piece?.WhichPiece == WhichPiece.King
&& piece?.Owner == whichPlayer;
};
// Find interesting pieces
var longRangePiecePositions = new List<BoardVector>(8);
Board.ForEachNotNull((piece, x, y) =>
{
if (piece.Owner != whichPlayer)
{
switch (piece.WhichPiece)
{
case WhichPiece.Bishop:
case WhichPiece.Rook:
longRangePiecePositions.Add(new BoardVector(x, y));
break;
case WhichPiece.Lance:
if (!piece.IsPromoted) longRangePiecePositions.Add(new BoardVector(x, y));
break;
}
}
});
foreach(var position in longRangePiecePositions)
{
IterateMoveSet(position, checkKingThreat);
}
return inCheck;
}
private bool ValidateMoveAgainstMoveSet(Move move)
{
var isValid = false;
IterateMoveSet(move.From, (piece, position) =>
{
if (piece?.Owner != WhoseTurn && position == move.To)
{
isValid = true;
}
});
return isValid;
}
/// <summary>
/// Iterate through the possible moves of a piece at a given position.
/// </summary>
private void IterateMoveSet(BoardVector from, MoveSetCallback callback)
{
// 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.
var piece = Board[from.X, from.Y];
switch (piece.WhichPiece)
{
case WhichPiece.King:
IterateKingMoveSet(from, callback);
break;
case WhichPiece.GoldenGeneral:
IterateGoldenGeneralMoveSet(from, callback);
break;
case WhichPiece.SilverGeneral:
IterateSilverGeneralMoveSet(from, callback);
break;
case WhichPiece.Bishop:
IterateBishopMoveSet(from, callback);
break;
case WhichPiece.Rook:
IterateRookMoveSet(from, callback);
break;
case WhichPiece.Knight:
IterateKnightMoveSet(from, callback);
break;
case WhichPiece.Lance:
IterateLanceMoveSet(from, callback);
break;
case WhichPiece.Pawn:
IteratePawnMoveSet(from, callback);
break;
}
}
private void IterateKingMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner);
BoardStep(from, direction.Up, callback);
BoardStep(from, direction.UpLeft, callback);
BoardStep(from, direction.UpRight, callback);
BoardStep(from, direction.Down, callback);
BoardStep(from, direction.DownLeft, callback);
BoardStep(from, direction.DownRight, callback);
BoardStep(from, direction.Left, callback);
BoardStep(from, direction.Right, callback);
}
private void IterateGoldenGeneralMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner);
BoardStep(from, direction.Up, callback);
BoardStep(from, direction.UpLeft, callback);
BoardStep(from, direction.UpRight, callback);
BoardStep(from, direction.Down, callback);
BoardStep(from, direction.Left, callback);
BoardStep(from, direction.Right, callback);
}
private void IterateSilverGeneralMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner);
if (piece.IsPromoted)
{
IterateGoldenGeneralMoveSet(from, callback);
}
else
{
BoardStep(from, direction.Up, callback);
BoardStep(from, direction.UpLeft, callback);
BoardStep(from, direction.UpRight, callback);
BoardStep(from, direction.DownLeft, callback);
BoardStep(from, direction.DownRight, callback);
}
}
private void IterateBishopMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner);
BoardWalk(from, direction.UpLeft, callback);
BoardWalk(from, direction.UpRight, callback);
BoardWalk(from, direction.DownLeft, callback);
BoardWalk(from, direction.DownRight, callback);
if (piece.IsPromoted)
{
BoardStep(from, direction.Up, callback);
BoardStep(from, direction.Left, callback);
BoardStep(from, direction.Right, callback);
BoardStep(from, direction.Down, callback);
}
}
private void IterateRookMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
var direction = new Direction(piece.Owner);
BoardWalk(from, direction.Up, callback);
BoardWalk(from, direction.Left, callback);
BoardWalk(from, direction.Right, callback);
BoardWalk(from, direction.Down, callback);
if (piece.IsPromoted)
{
BoardStep(from, direction.UpLeft, callback);
BoardStep(from, direction.UpRight, callback);
BoardStep(from, direction.DownLeft, callback);
BoardStep(from, direction.DownRight, callback);
}
}
private void IterateKnightMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
if (piece.IsPromoted)
{
IterateGoldenGeneralMoveSet(from, callback);
}
else
{
var direction = new Direction(piece.Owner);
BoardStep(from, direction.KnightLeft, callback);
BoardStep(from, direction.KnightRight, callback);
}
}
private void IterateLanceMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
if (piece.IsPromoted)
{
IterateGoldenGeneralMoveSet(from, callback);
}
else
{
var direction = new Direction(piece.Owner);
BoardWalk(from, direction.Up, callback);
}
}
private void IteratePawnMoveSet(BoardVector from, MoveSetCallback callback)
{
var piece = Board[from.X, from.Y];
if (piece?.WhichPiece == WhichPiece.Pawn)
{
if (piece.IsPromoted)
{
IterateGoldenGeneralMoveSet(from, callback);
}
else
{
var direction = new Direction(piece.Owner);
BoardStep(from, direction.Up, callback);
}
}
}
/// <summary>
/// Useful for iterating the board for pieces that move many spaces.
/// </summary>
/// <param name="callback">A function that returns true if walking should continue.</param>
private void BoardWalk(BoardVector from, BoardVector direction, MoveSetCallback callback)
{
var foundAnotherPiece = false;
var to = from.Add(direction);
while (to.IsValidBoardPosition && !foundAnotherPiece)
{
var piece = Board[to.X, to.Y];
callback(piece, to);
to = to.Add(direction);
foundAnotherPiece = piece != null;
}
}
/// <summary>
/// Useful for iterating the board for pieces that move only one space.
/// </summary>
private void BoardStep(BoardVector from, BoardVector direction, MoveSetCallback callback)
{
var to = from.Add(direction);
if (to.IsValidBoardPosition)
{
callback(Board[to.X, to.Y], to);
}
}
#endregion
#region Initialize
private void ResetEmptyRows()
{
for (int y = 3; y < 6; y++)
for (int x = 0; x < 9; x++)
Board[x, y] = null;
}
private void ResetFrontRow(WhichPlayer player)
{
int y = player == WhichPlayer.Player1 ? 2 : 6;
for (int x = 0; x < 9; x++) Board[x, y] = new Piece(WhichPiece.Pawn, player);
}
private void ResetMiddleRow(WhichPlayer player)
{
int y = player == WhichPlayer.Player1 ? 1 : 7;
Board[0, y] = null;
for (int x = 2; x < 7; x++) Board[x, y] = null;
Board[8, y] = null;
if (player == WhichPlayer.Player1)
{
Board[1, y] = new Piece(WhichPiece.Bishop, player);
Board[7, y] = new Piece(WhichPiece.Rook, player);
}
else
{
Board[1, y] = new Piece(WhichPiece.Rook, player);
Board[7, y] = new Piece(WhichPiece.Bishop, player);
}
}
private void ResetRearRow(WhichPlayer player)
{
int y = player == WhichPlayer.Player1 ? 0 : 8;
Board[0, y] = new Piece(WhichPiece.Lance, player);
Board[1, y] = new Piece(WhichPiece.Knight, player);
Board[2, y] = new Piece(WhichPiece.SilverGeneral, player);
Board[3, y] = new Piece(WhichPiece.GoldenGeneral, player);
Board[4, y] = new Piece(WhichPiece.King, player);
Board[5, y] = new Piece(WhichPiece.GoldenGeneral, player);
Board[6, y] = new Piece(WhichPiece.SilverGeneral, player);
Board[7, y] = new Piece(WhichPiece.Knight, player);
Board[8, y] = new Piece(WhichPiece.Lance, player);
}
private void InitializeBoardState()
{
ResetRearRow(WhichPlayer.Player1);
ResetMiddleRow(WhichPlayer.Player1);
ResetFrontRow(WhichPlayer.Player1);
ResetEmptyRows();
ResetFrontRow(WhichPlayer.Player2);
ResetMiddleRow(WhichPlayer.Player2);
ResetRearRow(WhichPlayer.Player2);
}
#endregion
}
}

14
Gameboard.ShogiUI.BoardState/WhichPiece.cs Normal file
View File

@@ -0,0 +1,14 @@
namespace Gameboard.ShogiUI.BoardState
{
public enum WhichPiece
{
King,
GoldenGeneral,
SilverGeneral,
Bishop,
Rook,
Knight,
Lance,
Pawn
}
}

8
Gameboard.ShogiUI.BoardState/WhichPlayer.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Gameboard.ShogiUI.BoardState
{
public enum WhichPlayer
{
Player1,
Player2
}
}

2
Gameboard.ShogiUI.Sockets.ServiceModels/Socket/Messages/ListGames.cs
View File

@@ -13,7 +13,7 @@ namespace Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages
{
public string Action { get; private set; }
public string Error { get; set; }
public IEnumerable<Game> Games { get; set; }
public ICollection<Game> Games { get; set; }
public ListGamesResponse(ClientAction action)
{

2
Gameboard.ShogiUI.Sockets.ServiceModels/Socket/Messages/LoadGame.cs
View File

@@ -14,7 +14,7 @@ namespace Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages
{
public string Action { get; private set; }
public Game Game { get; set; }
public IEnumerable<Move> Moves { get; set; }
public IReadOnlyList<Move> Moves { get; set; }
public string Error { get; set; }
public LoadGameResponse(ClientAction action)

11
Gameboard.ShogiUI.Sockets.ServiceModels/Socket/Types/BoardState.cs Normal file
View File

@@ -0,0 +1,11 @@
using System.Collections.Generic;
namespace Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types
{
public class BoardState
{
public Piece[,] Board { get; set; }
public IReadOnlyCollection<Piece> Player1Hand { get; set; }
public IReadOnlyCollection<Piece> Player2Hand { get; set; }
}
}

9
Gameboard.ShogiUI.Sockets.ServiceModels/Socket/Types/Game.cs
View File

@@ -1,8 +1,13 @@
namespace Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types
using System.Collections.Generic;
namespace Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types
{
public class Game
{
public string GameName { get; set; }
public string[] Players { get; set; }
/// <summary>
/// Players[0] is the session owner, Players[1] is the other guy
/// </summary>
public IReadOnlyList<string> Players { get; set; }
}
}

14
Gameboard.ShogiUI.Sockets.ServiceModels/Socket/Types/Piece.cs Normal file
View File

@@ -0,0 +1,14 @@
namespace Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types
{
public class Piece
{
public WhichPiece WhichPiece { get; set; }
/// <summary>
/// True if this piece is controlled by you.
/// </summary>
public bool IsControlledByMe { get; set; }
public bool IsPromoted { get; set; }
}
}

14
Gameboard.ShogiUI.Sockets.ServiceModels/Socket/Types/WhichPiece.cs Normal file
View File

@@ -0,0 +1,14 @@
namespace Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types
{
public enum WhichPiece
{
King,
GoldGeneral,
SilverGeneral,
Bishop,
Rook,
Knight,
Lance,
Pawn
}
}

24
Gameboard.ShogiUI.Sockets.sln
View File

@@ -9,7 +9,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Gameboard.ShogiUI.Sockets.S
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{F35A56FB-B8D8-4CB7-ABF6-D40049C9B42E}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Gameboard.ShogiUI.Sockets.UnitTests", "Gameboard.ShogiUI.Sockets.UnitTests\Gameboard.ShogiUI.Sockets.UnitTests.csproj", "{8D753AD0-0985-415C-80B3-CCADF3AE1DF9}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Gameboard.ShogiUI.BoardState", "Gameboard.ShogiUI.BoardState\Gameboard.ShogiUI.BoardState.csproj", "{C5A7C4EF-549F-40A8-A0BD-DA2C7C0A6CF4}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Gameboard.ShogiUI.UnitTests", "Gameboard.ShogiUI.UnitTests\Gameboard.ShogiUI.UnitTests.csproj", "{DC8A933A-DBCB-46B9-AA0B-7B3DC9E763F3}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Benchmarking", "Benchmarking\Benchmarking.csproj", "{DADFF5D6-581F-4D69-845D-53ABD6ABF62F}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -25,16 +29,24 @@ Global
{FE775DE4-50F0-4C5D-AD2B-01320B1E7086}.Debug|Any CPU.Build.0 = Debug|Any CPU
{FE775DE4-50F0-4C5D-AD2B-01320B1E7086}.Release|Any CPU.ActiveCfg = Release|Any CPU
{FE775DE4-50F0-4C5D-AD2B-01320B1E7086}.Release|Any CPU.Build.0 = Release|Any CPU
{8D753AD0-0985-415C-80B3-CCADF3AE1DF9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{8D753AD0-0985-415C-80B3-CCADF3AE1DF9}.Debug|Any CPU.Build.0 = Debug|Any CPU
{8D753AD0-0985-415C-80B3-CCADF3AE1DF9}.Release|Any CPU.ActiveCfg = Release|Any CPU
{8D753AD0-0985-415C-80B3-CCADF3AE1DF9}.Release|Any CPU.Build.0 = Release|Any CPU
{C5A7C4EF-549F-40A8-A0BD-DA2C7C0A6CF4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{C5A7C4EF-549F-40A8-A0BD-DA2C7C0A6CF4}.Debug|Any CPU.Build.0 = Debug|Any CPU
{C5A7C4EF-549F-40A8-A0BD-DA2C7C0A6CF4}.Release|Any CPU.ActiveCfg = Release|Any CPU
{C5A7C4EF-549F-40A8-A0BD-DA2C7C0A6CF4}.Release|Any CPU.Build.0 = Release|Any CPU
{DC8A933A-DBCB-46B9-AA0B-7B3DC9E763F3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{DC8A933A-DBCB-46B9-AA0B-7B3DC9E763F3}.Debug|Any CPU.Build.0 = Debug|Any CPU
{DC8A933A-DBCB-46B9-AA0B-7B3DC9E763F3}.Release|Any CPU.ActiveCfg = Release|Any CPU
{DC8A933A-DBCB-46B9-AA0B-7B3DC9E763F3}.Release|Any CPU.Build.0 = Release|Any CPU
{DADFF5D6-581F-4D69-845D-53ABD6ABF62F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{DADFF5D6-581F-4D69-845D-53ABD6ABF62F}.Debug|Any CPU.Build.0 = Debug|Any CPU
{DADFF5D6-581F-4D69-845D-53ABD6ABF62F}.Release|Any CPU.ActiveCfg = Release|Any CPU
{DADFF5D6-581F-4D69-845D-53ABD6ABF62F}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{8D753AD0-0985-415C-80B3-CCADF3AE1DF9} = {F35A56FB-B8D8-4CB7-ABF6-D40049C9B42E}
{DC8A933A-DBCB-46B9-AA0B-7B3DC9E763F3} = {F35A56FB-B8D8-4CB7-ABF6-D40049C9B42E}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {1D0B04F2-0DA1-4CB4-A82A-5A1C3B52ACEB}

1
Gameboard.ShogiUI.Sockets/Gameboard.ShogiUI.Sockets.csproj
View File

@@ -15,6 +15,7 @@
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Gameboard.ShogiUI.BoardState\Gameboard.ShogiUI.BoardState.csproj" />
<ProjectReference Include="..\Gameboard.ShogiUI.Sockets.ServiceModels\Gameboard.ShogiUI.Sockets.ServiceModels.csproj" />
</ItemGroup>

12
Gameboard.ShogiUI.Sockets/Gameboard.ShogiUI.Sockets.csproj.user
View File

@@ -1,12 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Controller_SelectedScaffolderID>ApiControllerEmptyScaffolder</Controller_SelectedScaffolderID>
<Controller_SelectedScaffolderCategoryPath>root/Controller</Controller_SelectedScaffolderCategoryPath>
<ActiveDebugProfile>AspShogiSockets</ActiveDebugProfile>
<ShowAllFiles>false</ShowAllFiles>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebuggerFlavor>ProjectDebugger</DebuggerFlavor>
</PropertyGroup>
</Project>

33
Gameboard.ShogiUI.Sockets/Managers/BoardManager.cs
View File

@@ -1,6 +1,35 @@
namespace Gameboard.ShogiUI.Sockets.Managers
using Gameboard.ShogiUI.BoardState;
using System.Collections.Concurrent;
namespace Gameboard.ShogiUI.Sockets.Managers
{
public class BoardManager
public interface IBoardManager
{
void Add(string sessionName, ShogiBoard board);
ShogiBoard Get(string sessionName);
}
public class BoardManager : IBoardManager
{
private readonly ConcurrentDictionary<string, ShogiBoard> Boards;
public BoardManager()
{
Boards = new ConcurrentDictionary<string, ShogiBoard>();
}
public void Add(string sessionName, ShogiBoard board) => Boards.TryAdd(sessionName, board);
public ShogiBoard Get(string sessionName)
{
if (Boards.TryGetValue(sessionName, out var board))
return board;
return null;
}
public string GetBoardState()
{
return string.Empty;
}
}
}

12
Gameboard.ShogiUI.Sockets/Managers/ClientActionHandlers/CreateGameHandler.cs
View File

@@ -1,15 +1,15 @@
using Gameboard.Shogi.Api.ServiceModels.Messages;
using Gameboard.ShogiUI.Sockets.Extensions;
using Gameboard.ShogiUI.Sockets.Repositories;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System.Net.WebSockets;
using System.Threading.Tasks;
namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
{
// TODO: This doesn't need to be a socket action.
// It can be an API route and still tell socket connections about the new session.
public class CreateGameHandler : IActionHandler
{
private readonly ILogger<CreateGameHandler> logger;
@@ -26,13 +26,13 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
this.communicationManager = communicationManager;
}
public async Task Handle(WebSocket socket, string json, string userName)
public async Task Handle(string json, string userName)
{
var request = JsonConvert.DeserializeObject<CreateGameRequest>(json);
var postSessionResponse = await repository.PostSession(new PostSession
{
SessionName = request.GameName,
PlayerName = userName, // TODO : Investigate if needed by UI
PlayerName = userName,
IsPrivate = request.IsPrivate
});
@@ -53,9 +53,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
if (request.IsPrivate)
{
var serialized = JsonConvert.SerializeObject(response);
logger.LogInformation("Response to {0} \n{1}\n", userName, serialized);
await socket.SendTextAsync(serialized);
await communicationManager.BroadcastToPlayers(response, userName);
}
else
{

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

@@ -9,7 +9,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
/// <summary>
/// Responsible for parsing json and handling the request.
/// </summary>
Task Handle(WebSocket socket, string json, string userName);
Task Handle(string json, string userName);
}
public delegate IActionHandler ActionHandlerResolver(ClientAction action);

25
Gameboard.ShogiUI.Sockets/Managers/ClientActionHandlers/JoinByCodeHandler.cs
View File

@@ -1,11 +1,9 @@
using Gameboard.Shogi.Api.ServiceModels.Messages;
using Gameboard.ShogiUI.Sockets.Extensions;
using Gameboard.ShogiUI.Sockets.Repositories;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System.Net.WebSockets;
using System.Threading.Tasks;
namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
@@ -26,7 +24,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
this.communicationManager = communicationManager;
}
public async Task Handle(WebSocket socket, string json, string userName)
public async Task Handle(string json, string userName)
{
var request = JsonConvert.DeserializeObject<JoinByCode>(json);
var joinGameResponse = await repository.PostJoinPrivateSession(new PostJoinPrivateSession
@@ -37,37 +35,32 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
if (joinGameResponse.JoinSucceeded)
{
var gameName = (await repository.GetGame(joinGameResponse.SessionName)).Session.Name;
// Other members of the game see a regular JoinGame occur.
var response = new JoinGameResponse(ClientAction.JoinGame)
{
PlayerName = userName,
GameName = gameName
GameName = joinGameResponse.SessionName
};
// At this time, userName hasn't subscribed and won't receive this broadcasted messages.
await communicationManager.BroadcastToGame(gameName, response);
// At this time, userName hasn't subscribed and won't receive this message.
await communicationManager.BroadcastToGame(joinGameResponse.SessionName, response);
// But the player joining sees the JoinByCode occur.
// The player joining sees the JoinByCode occur.
response = new JoinGameResponse(ClientAction.JoinByCode)
{
PlayerName = userName,
GameName = gameName
GameName = joinGameResponse.SessionName
};
var serialized = JsonConvert.SerializeObject(response);
logger.LogInformation("Response to {0} \n{1}\n", userName, serialized);
await socket.SendTextAsync(serialized);
await communicationManager.BroadcastToPlayers(response, userName);
}
else
{
var response = new JoinGameResponse(ClientAction.JoinByCode)
{
PlayerName = userName,
GameName = joinGameResponse.SessionName,
Error = "Error joining game."
};
var serialized = JsonConvert.SerializeObject(response);
logger.LogInformation("Response to {0} \n{1}\n", userName, serialized);
await socket.SendTextAsync(serialized);
await communicationManager.BroadcastToPlayers(response, userName);
}
}
}

18
Gameboard.ShogiUI.Sockets/Managers/ClientActionHandlers/JoinGameHandler.cs
View File

@@ -3,7 +3,6 @@ using Gameboard.ShogiUI.Sockets.Repositories;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
using Newtonsoft.Json;
using System.Net.WebSockets;
using System.Threading.Tasks;
namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
@@ -20,13 +19,9 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
this.communicationManager = communicationManager;
}
public async Task Handle(WebSocket socket, string json, string userName)
public async Task Handle(string json, string userName)
{
var request = JsonConvert.DeserializeObject<JoinGameRequest>(json);
var response = new JoinGameResponse(ClientAction.JoinGame)
{
PlayerName = userName
};
var joinGameResponse = await gameboardRepository.PutJoinPublicSession(new PutJoinPublicSession
{
@@ -34,15 +29,20 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
SessionName = request.GameName
});
var response = new JoinGameResponse(ClientAction.JoinGame)
{
PlayerName = userName,
GameName = request.GameName
};
if (joinGameResponse.JoinSucceeded)
{
response.GameName = request.GameName;
await communicationManager.BroadcastToAll(response);
}
else
{
response.Error = "Game is full.";
}
await communicationManager.BroadcastToAll(response);
await communicationManager.BroadcastToPlayers(response, userName);
}
}
}
}

16
Gameboard.ShogiUI.Sockets/Managers/ClientActionHandlers/ListGamesHandler.cs
View File

@@ -1,26 +1,29 @@
using Gameboard.ShogiUI.Sockets.Extensions;
using Gameboard.ShogiUI.Sockets.Models;
using Gameboard.ShogiUI.Sockets.Models;
using Gameboard.ShogiUI.Sockets.Repositories;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
using Newtonsoft.Json;
using System.Linq;
using System.Net.WebSockets;
using System.Threading.Tasks;
namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
{
// TODO: This doesn't need to be a socket action.
// It can be an HTTP route.
public class ListGamesHandler : IActionHandler
{
private readonly ISocketCommunicationManager communicationManager;
private readonly IGameboardRepository repository;
public ListGamesHandler(
ISocketCommunicationManager communicationManager,
IGameboardRepository repository)
{
this.communicationManager = communicationManager;
this.repository = repository;
}
public async Task Handle(WebSocket socket, string json, string userName)
public async Task Handle(string json, string userName)
{
var request = JsonConvert.DeserializeObject<ListGamesRequest>(json);
var getGamesResponse = string.IsNullOrWhiteSpace(userName)
@@ -33,11 +36,10 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
var response = new ListGamesResponse(ClientAction.ListGames)
{
Games = games
Games = games.ToList()
};
var serialized = JsonConvert.SerializeObject(response);
await socket.SendTextAsync(serialized);
await communicationManager.BroadcastToPlayers(response, userName);
}
}
}

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

@@ -1,56 +1,66 @@
using Gameboard.ShogiUI.Sockets.Extensions;
using Gameboard.ShogiUI.Sockets.Managers.Utility;
using Gameboard.ShogiUI.Sockets.Models;
using Gameboard.ShogiUI.BoardState;
using Gameboard.ShogiUI.Sockets.Repositories;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System.Linq;
using System.Net.WebSockets;
using System.Threading.Tasks;
namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
{
/// <summary>
/// Subscribes a user to messages for a session and loads that session into the BoardManager for playing.
/// </summary>
public class LoadGameHandler : IActionHandler
{
private readonly ILogger<LoadGameHandler> logger;
private readonly IGameboardRepository gameboardRepository;
private readonly ISocketCommunicationManager communicationManager;
private readonly IBoardManager boardManager;
public LoadGameHandler(
ILogger<LoadGameHandler> logger,
ISocketCommunicationManager communicationManager,
IGameboardRepository gameboardRepository)
IGameboardRepository gameboardRepository,
IBoardManager boardManager)
{
this.logger = logger;
this.gameboardRepository = gameboardRepository;
this.communicationManager = communicationManager;
this.boardManager = boardManager;
}
public async Task Handle(WebSocket socket, string json, string userName)
public async Task Handle(string json, string userName)
{
var request = JsonConvert.DeserializeObject<LoadGameRequest>(json);
var getGameResponse = await gameboardRepository.GetGame(request.GameName);
var getMovesResponse = await gameboardRepository.GetMoves(request.GameName);
var gameTask = gameboardRepository.GetGame(request.GameName);
var moveTask = gameboardRepository.GetMoves(request.GameName);
var response = new LoadGameResponse(ClientAction.LoadGame);
var getGameResponse = await gameTask;
var getMovesResponse = await moveTask;
if (getGameResponse == null || getMovesResponse == null)
{
response.Error = $"Could not find game.";
logger.LogWarning("{action} - {user} was unable to load session named {session}.", ClientAction.LoadGame, userName, request.GameName);
var response = new LoadGameResponse(ClientAction.LoadGame) { Error = "Game not found." };
await communicationManager.BroadcastToPlayers(response, userName);
}
else
{
var sessionModel = new Session(getGameResponse.Session);
communicationManager.SubscribeToGame(socket, sessionModel, userName);
var sessionModel = new Models.Session(getGameResponse.Session);
var moveModels = getMovesResponse.Moves.Select(_ => new Models.Move(_)).ToList();
response.Game = sessionModel.ToServiceModel();
response.Moves = getMovesResponse.Moves.Select(_ => Mapper.Map(_).ToServiceModel());
}
communicationManager.SubscribeToGame(sessionModel, userName);
var boardMoves = moveModels.Select(_ => _.ToBoardModel()).ToList();
boardManager.Add(getGameResponse.Session.Name, new ShogiBoard(boardMoves));
var serialized = JsonConvert.SerializeObject(response);
logger.LogInformation("Response to {0} \n{1}\n", userName, serialized);
await socket.SendTextAsync(serialized);
var response = new LoadGameResponse(ClientAction.LoadGame)
{
Game = sessionModel.ToServiceModel(),
Moves = moveModels.Select(_ => _.ToServiceModel()).ToList(),
};
await communicationManager.BroadcastToPlayers(response, userName);
}
}
}
}

32
Gameboard.ShogiUI.Sockets/Managers/ClientActionHandlers/MoveHandler.cs
View File

@@ -1,45 +1,47 @@
using Gameboard.Shogi.Api.ServiceModels.Messages;
using Gameboard.ShogiUI.Sockets.Extensions;
using Gameboard.ShogiUI.Sockets.Managers.Utility;
using Gameboard.ShogiUI.Sockets.Repositories;
using Service = Gameboard.ShogiUI.Sockets.ServiceModels.Socket;
using Newtonsoft.Json;
using System.Net.WebSockets;
using System.Threading.Tasks;
using Gameboard.ShogiUI.Sockets.Models;
using Gameboard.ShogiUI.Sockets.Repositories;
using Newtonsoft.Json;
using System.Threading.Tasks;
using Service = Gameboard.ShogiUI.Sockets.ServiceModels.Socket;
namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
{
public class MoveHandler : IActionHandler
{
private readonly IBoardManager boardManager;
private readonly IGameboardRepository gameboardRepository;
private readonly ISocketCommunicationManager communicationManager;
public MoveHandler(
IBoardManager boardManager,
ISocketCommunicationManager communicationManager,
IGameboardRepository gameboardRepository)
{
this.boardManager = boardManager;
this.gameboardRepository = gameboardRepository;
this.communicationManager = communicationManager;
}
public async Task Handle(WebSocket socket, string json, string userName)
public async Task Handle(string json, string userName)
{
var request = JsonConvert.DeserializeObject<Service.Messages.MoveRequest>(json);
// Basic move validation
if (request.Move.To.Equals(request.Move.From))
{
var serialized = JsonConvert.SerializeObject(
new Service.Messages.ErrorResponse(Service.Types.ClientAction.Move)
var error = new Service.Messages.ErrorResponse(Service.Types.ClientAction.Move)
{
Error = "Error: moving piece from tile to the same tile."
});
await socket.SendTextAsync(serialized);
};
await communicationManager.BroadcastToPlayers(error, userName);
return;
}
var moveModel = new Move(request.Move);
var session = (await gameboardRepository.GetGame(request.GameName)).Session;
await gameboardRepository.PostMove(request.GameName, new PostMove(Mapper.Map(moveModel)));
var board = boardManager.Get(request.GameName);
var boardMove = moveModel.ToBoardModel();
//board.Move()
await gameboardRepository.PostMove(request.GameName, new PostMove(moveModel.ToApiModel()));
var response = new Service.Messages.MoveResponse(Service.Types.ClientAction.Move)
{
@@ -47,7 +49,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers
PlayerName = userName,
Move = moveModel.ToServiceModel()
};
await communicationManager.BroadcastToGame(session.Name, response);
await communicationManager.BroadcastToGame(request.GameName, response);
}
}
}

25
Gameboard.ShogiUI.Sockets/Managers/SocketCommunicationManager.cs
View File

@@ -21,10 +21,11 @@ namespace Gameboard.ShogiUI.Sockets.Managers
Task BroadcastToAll(IResponse response);
Task BroadcastToGame(string gameName, IResponse response);
Task BroadcastToGame(string gameName, IResponse forPlayer1, IResponse forPlayer2);
void SubscribeToGame(WebSocket socket, Session session, string playerName);
void SubscribeToGame(Session session, string playerName);
void SubscribeToBroadcast(WebSocket socket, string playerName);
void UnsubscribeFromBroadcastAndGames(string playerName);
void UnsubscribeFromGame(string gameName, string playerName);
Task BroadcastToPlayers(IResponse response, params string[] playerNames);
}
public class SocketCommunicationManager : ISocketCommunicationManager
@@ -65,7 +66,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers
else
{
var handler = handlerResolver(request.Action);
await handler.Handle(socket, message, userName);
await handler.Handle(message, userName);
}
}
catch (OperationCanceledException ex)
@@ -100,7 +101,7 @@ namespace Gameboard.ShogiUI.Sockets.Managers
/// <summary>
/// Unsubscribes the player from their current game, then subscribes to the new game.
/// </summary>
public void SubscribeToGame(WebSocket socket, Session session, string playerName)
public void SubscribeToGame(Session session, string playerName)
{
// Unsubscribe from any other games
foreach (var kvp in sessions)
@@ -110,9 +111,12 @@ namespace Gameboard.ShogiUI.Sockets.Managers
}
// Subscribe
if (connections.TryGetValue(playerName, out var socket))
{
var s = sessions.GetOrAdd(session.Name, session);
s.Subscriptions.TryAdd(playerName, socket);
}
}
public void UnsubscribeFromGame(string gameName, string playerName)
{
@@ -123,6 +127,21 @@ namespace Gameboard.ShogiUI.Sockets.Managers
}
}
public async Task BroadcastToPlayers(IResponse response, params string[] playerNames)
{
var tasks = new List<Task>(playerNames.Length);
foreach (var name in playerNames)
{
if (connections.TryGetValue(name, out var socket))
{
var serialized = JsonConvert.SerializeObject(response);
logger.LogInformation("Response to {0} \n{1}\n", name, serialized);
tasks.Add(socket.SendTextAsync(serialized));
}
}
await Task.WhenAll(tasks);
}
public Task BroadcastToAll(IResponse response)
{
var message = JsonConvert.SerializeObject(response);

67
Gameboard.ShogiUI.Sockets/Managers/Utility/Mapper.cs
View File

@@ -1,67 +0,0 @@
using Gameboard.ShogiUI.Sockets.Models;
using Microsoft.FSharp.Core;
using ShogiApi = Gameboard.Shogi.Api.ServiceModels.Types;
namespace Gameboard.ShogiUI.Sockets.Managers.Utility
{
public static class Mapper
{
public static ShogiApi.Move Map(Move source)
{
var from = source.From;
var to = source.To;
FSharpOption<ShogiApi.WhichPieceName> pieceFromCaptured = source.PieceFromCaptured switch
{
"B" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Bishop),
"G" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.GoldenGeneral),
"K" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.King),
"k" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Knight),
"L" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Lance),
"P" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Pawn),
"R" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Rook),
"S" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.SilverGeneral),
_ => null
};
var target = new ShogiApi.Move
{
Origin = new ShogiApi.BoardLocation { X = from.X, Y = from.Y },
Destination = new ShogiApi.BoardLocation { X = to.X, Y = to.Y },
IsPromotion = source.IsPromotion,
PieceFromCaptured = pieceFromCaptured
};
return target;
}
public static Move Map(ShogiApi.Move source)
{
var origin = source.Origin;
var destination = source.Destination;
string pieceFromCaptured = null;
if (source.PieceFromCaptured != null)
{
pieceFromCaptured = source.PieceFromCaptured.Value switch
{
ShogiApi.WhichPieceName.Bishop => "B",
ShogiApi.WhichPieceName.GoldenGeneral => "G",
ShogiApi.WhichPieceName.King => "K",
ShogiApi.WhichPieceName.Knight => "k",
ShogiApi.WhichPieceName.Lance => "L",
ShogiApi.WhichPieceName.Pawn => "P",
ShogiApi.WhichPieceName.Rook => "R",
ShogiApi.WhichPieceName.SilverGeneral => "S",
_ => ""
};
}
var target = new Move
{
From = new Coords(origin.X, origin.Y),
To = new Coords(destination.X, destination.Y),
IsPromotion = source.IsPromotion,
PieceFromCaptured = pieceFromCaptured
};
return target;
}
}
}

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

@@ -1,4 +1,9 @@
namespace Gameboard.ShogiUI.Sockets.Models
using Gameboard.ShogiUI.BoardState;
using Microsoft.FSharp.Core;
using System;
using ShogiApi = Gameboard.Shogi.Api.ServiceModels.Types;
namespace Gameboard.ShogiUI.Sockets.Models
{
public class Move
{
@@ -15,7 +20,29 @@
PieceFromCaptured = move.PieceFromCaptured;
IsPromotion = move.IsPromotion;
}
public Move(ShogiApi.Move move)
{
string pieceFromCaptured = null;
if (move.PieceFromCaptured != null)
{
pieceFromCaptured = move.PieceFromCaptured.Value switch
{
ShogiApi.WhichPieceName.Bishop => "",
ShogiApi.WhichPieceName.GoldenGeneral => "G",
ShogiApi.WhichPieceName.King => "K",
ShogiApi.WhichPieceName.Knight => "k",
ShogiApi.WhichPieceName.Lance => "L",
ShogiApi.WhichPieceName.Pawn => "P",
ShogiApi.WhichPieceName.Rook => "R",
ShogiApi.WhichPieceName.SilverGeneral => "S",
_ => ""
};
}
From = new Coords(move.Origin.X, move.Origin.Y);
To = new Coords(move.Destination.X, move.Destination.Y);
IsPromotion = move.IsPromotion;
PieceFromCaptured = pieceFromCaptured;
}
public ServiceModels.Socket.Types.Move ToServiceModel() => new ServiceModels.Socket.Types.Move
{
From = From.ToBoardNotation(),
@@ -23,5 +50,38 @@
PieceFromCaptured = PieceFromCaptured,
To = To.ToBoardNotation()
};
public ShogiApi.Move ToApiModel()
{
var pieceFromCaptured = PieceFromCaptured switch
{
"B" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Bishop),
"G" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.GoldenGeneral),
"K" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.King),
"k" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Knight),
"L" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Lance),
"P" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Pawn),
"R" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.Rook),
"S" => new FSharpOption<ShogiApi.WhichPieceName>(ShogiApi.WhichPieceName.SilverGeneral),
_ => null
};
var target = new ShogiApi.Move
{
Origin = new ShogiApi.BoardLocation { X = From.X, Y = From.Y },
Destination = new ShogiApi.BoardLocation { X = To.X, Y = To.Y },
IsPromotion = IsPromotion,
PieceFromCaptured = pieceFromCaptured
};
return target;
}
public BoardState.Move ToBoardModel()
{
return new BoardState.Move
{
From = new BoardVector(From.X, From.Y),
IsPromotion = IsPromotion,
PieceFromCaptured = Enum.TryParse<WhichPiece>(PieceFromCaptured, out var whichPiece) ? whichPiece : null,
To = new BoardVector(To.X, To.Y)
};
}
}
}

1
Gameboard.ShogiUI.Sockets/Startup.cs
View File

@@ -45,6 +45,7 @@ namespace Gameboard.ShogiUI.Sockets
services.AddSingleton<ISocketTokenManager, SocketTokenManager>();
services.AddSingleton<ISocketConnectionManager, SocketConnectionManager>();
services.AddScoped<IGameboardRepositoryManager, GameboardRepositoryManager>();
services.AddSingleton<IBoardManager, BoardManager>();
services.AddSingleton<ActionHandlerResolver>(sp => action =>
{
return action switch

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

@@ -0,0 +1,26 @@
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();
}
}
}

322
Gameboard.ShogiUI.UnitTests/BoardState/ShogiBoardShould.cs Normal file
View File

@@ -0,0 +1,322 @@
using FluentAssertions;
using Gameboard.ShogiUI.BoardState;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Linq;
namespace Gameboard.ShogiUI.UnitTests.BoardState
{
[TestClass]
public class ShogiBoardShould
{
[TestMethod]
public void InitializeBoardState()
{
// Assert
var board = new ShogiBoard().Board;
// Assert pieces do not start promoted.
foreach (var piece in board) piece?.IsPromoted.Should().BeFalse();
// Assert Player1.
for (var y = 0; y < 3; y++)
for (var x = 0; x < 9; x++)
board[x, y]?.Owner.Should().Be(WhichPlayer.Player1);
board[0, 0].WhichPiece.Should().Be(WhichPiece.Lance);
board[1, 0].WhichPiece.Should().Be(WhichPiece.Knight);
board[2, 0].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[3, 0].WhichPiece.Should().Be(WhichPiece.GoldenGeneral);
board[4, 0].WhichPiece.Should().Be(WhichPiece.King);
board[5, 0].WhichPiece.Should().Be(WhichPiece.GoldenGeneral);
board[6, 0].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[7, 0].WhichPiece.Should().Be(WhichPiece.Knight);
board[8, 0].WhichPiece.Should().Be(WhichPiece.Lance);
board[0, 1].Should().BeNull();
board[1, 1].WhichPiece.Should().Be(WhichPiece.Bishop);
for (var x = 2; x < 7; x++) board[x, 1].Should().BeNull();
board[7, 1].WhichPiece.Should().Be(WhichPiece.Rook);
board[8, 1].Should().BeNull();
for (var x = 0; x < 9; x++) board[x, 2].WhichPiece.Should().Be(WhichPiece.Pawn);
// Assert empty locations.
for (var y = 3; y < 6; y++)
for (var x = 0; x < 9; x++)
board[x, y].Should().BeNull();
// Assert Player2.
for (var y = 6; y < 9; y++)
for (var x = 0; x < 9; x++)
board[x, y]?.Owner.Should().Be(WhichPlayer.Player2);
board[0, 8].WhichPiece.Should().Be(WhichPiece.Lance);
board[1, 8].WhichPiece.Should().Be(WhichPiece.Knight);
board[2, 8].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[3, 8].WhichPiece.Should().Be(WhichPiece.GoldenGeneral);
board[4, 8].WhichPiece.Should().Be(WhichPiece.King);
board[5, 8].WhichPiece.Should().Be(WhichPiece.GoldenGeneral);
board[6, 8].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[7, 8].WhichPiece.Should().Be(WhichPiece.Knight);
board[8, 8].WhichPiece.Should().Be(WhichPiece.Lance);
board[0, 7].Should().BeNull();
board[1, 7].WhichPiece.Should().Be(WhichPiece.Rook);
for (var x = 2; x < 7; x++) board[x, 7].Should().BeNull();
board[7, 7].WhichPiece.Should().Be(WhichPiece.Bishop);
board[8, 7].Should().BeNull();
for (var x = 0; x < 9; x++) board[x, 6].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
public void InitializeBoardStateWithMoves()
{
var moves = new[]
{
new Move
{
// Pawn
From = new BoardVector(0, 2),
To = new BoardVector(0, 3)
}
};
var shogi = new ShogiBoard(moves);
shogi.Board[0, 2].Should().BeNull();
shogi.Board[0, 3].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
public void PreventInvalidMoves_MoveToCurrentPosition()
{
// Arrange
var shogi = new ShogiBoard();
// 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) });
// Assert
moveSuccess.Should().BeFalse();
shogi.Board[0, 2].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
public void PreventInvalidMoves_MoveSet()
{
var invalidLanceMove = new Move
{
// Lance moving adjacent
From = new BoardVector(0, 0),
To = new BoardVector(1, 5)
};
var shogi = new ShogiBoard();
var moveSuccess = shogi.TryMove(invalidLanceMove);
moveSuccess.Should().BeFalse();
// Assert the Lance has not actually moved.
shogi.Board[0, 0].WhichPiece.Should().Be(WhichPiece.Lance);
}
[TestMethod]
public void PreventInvalidMoves_Ownership()
{
// Arrange
var shogi = new ShogiBoard();
// 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) });
// Assert
moveSuccess.Should().BeFalse();
shogi.Board[8, 6].WhichPiece.Should().Be(WhichPiece.Pawn);
shogi.Board[8, 5].Should().BeNull();
}
[TestMethod]
public void PreventInvalidMoves_MoveThroughAllies()
{
var invalidLanceMove = new Move
{
// Lance moving through the pawn before it.
From = new BoardVector(0, 0),
To = new BoardVector(0, 5)
};
var shogi = new ShogiBoard();
var moveSuccess = shogi.TryMove(invalidLanceMove);
moveSuccess.Should().BeFalse();
// Assert the Lance has not actually moved.
shogi.Board[0, 0].WhichPiece.Should().Be(WhichPiece.Lance);
}
[TestMethod]
public void PreventInvalidMoves_CaptureAlly()
{
var invalidKnightMove = new Move
{
// Knight capturing allied Pawn
From = new BoardVector(1, 0),
To = new BoardVector(0, 2)
};
var shogi = new ShogiBoard();
var moveSuccess = shogi.TryMove(invalidKnightMove);
moveSuccess.Should().BeFalse();
// Assert the Knight has not actually moved or captured.
shogi.Board[1, 0].WhichPiece.Should().Be(WhichPiece.Knight);
shogi.Board[0, 2].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
public void PreventInvalidMoves_Check()
{
// Arrange
var moves = new[]
{
// P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) },
// P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) },
// P1 Bishop puts P2 in check
new Move { From = new BoardVector(1, 1), To = new BoardVector(6, 6) }
};
var shogi = new ShogiBoard(moves);
// Prerequisit
shogi.InCheck.Should().Be(WhichPlayer.Player2);
// Act - P2 moves Lance while remaining in check.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(8, 8), To = new BoardVector(8, 7) });
// Assert
moveSuccess.Should().BeFalse();
shogi.InCheck.Should().Be(WhichPlayer.Player2);
shogi.Board[8, 8].WhichPiece.Should().Be(WhichPiece.Lance);
shogi.Board[8, 7].Should().BeNull();
}
[TestMethod]
public void Check()
{
// Arrange
var moves = new[]
{
// P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) },
// P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) },
};
var shogi = new ShogiBoard(moves);
// Act - P1 Bishop, check
shogi.TryMove(new Move { From = new BoardVector(1, 1), To = new BoardVector(6, 6) });
// Assert
shogi.InCheck.Should().Be(WhichPlayer.Player2);
}
[TestMethod]
public void Capture()
{
// Arrange
var moves = new[]
{
// P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) },
// P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) }
};
var shogi = new ShogiBoard(moves);
// Act - P1 Bishop captures P2 Bishop
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(1, 1), To = new BoardVector(7, 7) });
// Assert
moveSuccess.Should().BeTrue();
shogi.Board
.Cast<Piece>()
.Count(piece => piece?.WhichPiece == WhichPiece.Bishop)
.Should()
.Be(1);
shogi.Board[1, 1].Should().BeNull();
shogi.Board[7, 7].WhichPiece.Should().Be(WhichPiece.Bishop);
shogi.Hands[WhichPlayer.Player1]
.Should()
.ContainSingle(piece => piece.WhichPiece == WhichPiece.Bishop && piece.Owner == WhichPlayer.Player1);
// Act - P2 Silver captures P1 Bishop
moveSuccess = shogi.TryMove(new Move { From = new BoardVector(6, 8), To = new BoardVector(7, 7) });
// Assert
moveSuccess.Should().BeTrue();
shogi.Board[6, 8].Should().BeNull();
shogi.Board[7, 7].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
shogi.Board
.Cast<Piece>()
.Count(piece => piece?.WhichPiece == WhichPiece.Bishop)
.Should().Be(0);
shogi.Hands[WhichPlayer.Player2]
.Should()
.ContainSingle(piece => piece.WhichPiece == WhichPiece.Bishop && piece.Owner == WhichPlayer.Player2);
}
[TestMethod]
public void Promote()
{
// Arrange
var moves = new[]
{
// P1 Pawn
new Move { From = new BoardVector(2, 2), To = new BoardVector(2, 3) },
// P2 Pawn
new Move { From = new BoardVector(6, 6), To = new BoardVector(6, 5) }
};
var shogi = new ShogiBoard(moves);
// Act - P1 moves across promote threshold.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(1, 1), To = new BoardVector(6, 6), IsPromotion = true });
// Assert
moveSuccess.Should().BeTrue();
shogi.Board[1, 1].Should().BeNull();
shogi.Board[6, 6].Should().Match<Piece>(piece => piece.WhichPiece == WhichPiece.Bishop && piece.IsPromoted == true);
}
[TestMethod]
public void CheckMate()
{
// Arrange
var moves = new[]
{
// P1 Rook
new Move { From = new BoardVector(7, 1), To = new BoardVector(4, 1) },
// P2 Gold
new Move { From = new BoardVector(3, 8), To = new BoardVector(2, 7) },
// P1 Pawn
new Move { From = new BoardVector(4, 2), To = new BoardVector(4, 3) },
// P2 other Gold
new Move { From = new BoardVector(5, 8), To = new BoardVector(6, 7) },
// P1 same Pawn
new Move { From = new BoardVector(4, 3), To = new BoardVector(4, 4) },
// P2 Pawn
new Move { From = new BoardVector(4, 6), To = new BoardVector(4, 5) },
// P1 Pawn takes P2 Pawn
new Move { From = new BoardVector(4, 4), To = new BoardVector(4, 5) },
// P2 King
new Move { From = new BoardVector(4, 8), To = new BoardVector(4, 7) },
// P1 Pawn promotes
new Move { From = new BoardVector(4, 5), To = new BoardVector(4, 6), IsPromotion = true },
// P2 King retreat
new Move { From = new BoardVector(4, 7), To = new BoardVector(4, 8) },
};
var shogi = new ShogiBoard(moves);
// Act - P1 Pawn wins by checkmate.
var moveSuccess = shogi.TryMove(new Move { From = new BoardVector(4, 6), To = new BoardVector(4, 7) });
// Assert
moveSuccess.Should().BeTrue();
shogi.IsCheckmate.Should().BeTrue();
}
}
}

0
Gameboard.ShogiUI.Sockets.UnitTests/Gameboard.ShogiUI.Sockets.UnitTests.csproj → Gameboard.ShogiUI.UnitTests/Gameboard.ShogiUI.UnitTests.csproj
View File

2
Gameboard.ShogiUI.Sockets.UnitTests/Models/CoordsModelShould.cs → Gameboard.ShogiUI.UnitTests/Sockets/CoordsModelShould.cs
View File

@@ -2,7 +2,7 @@
using Gameboard.ShogiUI.Sockets.Models;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Gameboard.ShogiUI.Sockets.UnitTests.Models
namespace Gameboard.ShogiUI.UnitTests.Sockets
{
[TestClass]
public class CoordsModelShould