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

Before changing Piece[,] to Dictionary<string,Piece>

Browse Source
This commit is contained in:
Lucas Morgan
2021-07-26 06:28:56 -05:00
parent f8f779e84c
commit 178cb00253
73 changed files with 1537 additions and 1418 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Gameboard.ShogiUI.UnitTests/Gameboard.ShogiUI.UnitTests.csproj
View File

@@ -5,10 +5,12 @@
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AutoFixture" Version="4.17.0" />
<PackageReference Include="FluentAssertions" Version="5.10.3" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
<PackageReference Include="MSTest.TestAdapter" Version="2.1.2" />
<PackageReference Include="MSTest.TestFramework" Version="2.1.2" />
<PackageReference Include="xunit" Version="2.4.1" />
</ItemGroup>
<ItemGroup>

92
Gameboard.ShogiUI.UnitTests/PathFinding/PlanarCollectionShould.cs Normal file
View File

@@ -0,0 +1,92 @@
using AutoFixture;
using FluentAssertions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using PathFinding;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Gameboard.ShogiUI.UnitTests.PathFinding
{
[TestClass]
public class PlanarCollectionShould
{
private class SimpleElement : IPlanarElement
{
public static int Seed { get; private set; }
public MoveSet MoveSet => null;
public bool IsUpsideDown => false;
public SimpleElement()
{
Seed = Seed++;
}
}
private Fixture fixture;
[TestInitialize]
public void TestInitialize()
{
fixture = new Fixture();
}
[TestMethod]
public void Index()
{
// Arrange
var collection = new PlanarCollection<SimpleElement>(10, 10);
var expected1 = new SimpleElement();
var expected2 = new SimpleElement();
// Act
collection[0, 0] = expected1;
collection[2, 1] = expected2;
// Assert
collection[0, 0].Should().Be(expected1);
collection[2, 1].Should().Be(expected2);
}
[TestMethod]
public void Iterate()
{
// Arrange
var expected = new List<SimpleElement>();
for (var i = 0; i < 9; i++) expected.Add(new SimpleElement());
var collection = new PlanarCollection<SimpleElement>(3, 3);
for (var x = 0; x < 3; x++)
for (var y = 0; y < 3; y++)
collection[x, y] = expected[x + y];
// Act
var actual = new List<SimpleElement>();
foreach (var elem in collection)
actual.Add(elem);
// Assert
actual.Should().BeEquivalentTo(expected);
}
[TestMethod]
public void Yep()
{
var collection = new PlanarCollection<SimpleElement>(3, 3);
collection[0, 0] = new SimpleElement();
collection[1, 0] = new SimpleElement();
collection[0, 1] = new SimpleElement();
// Act
var array2d = new SimpleElement[3, 3];
for (var x = 0; x < 3; x++)
for (var y = 0; y < 3; y++)
{
array2d[x, y] = collection[x, y];
}
Console.WriteLine("hey");
}
}
}

65
Gameboard.ShogiUI.UnitTests/Rules/BoardStateExtensions.cs
View File

@@ -1,65 +0,0 @@
using Gameboard.ShogiUI.Rules;
using Gameboard.ShogiUI.Rules.Pieces;
using System;
using System.Text;
using System.Text.RegularExpressions;
namespace Gameboard.ShogiUI.UnitTests.Rules
{
public static class BoardStateExtensions
{
public static string GetShortName(this Piece self)
{
var name = self.WhichPiece switch
{
WhichPiece.King => " K ",
WhichPiece.GoldGeneral => " G ",
WhichPiece.SilverGeneral => self.IsPromoted ? "^S " : " S ",
WhichPiece.Bishop => self.IsPromoted ? "^B " : " B ",
WhichPiece.Rook => self.IsPromoted ? "^R " : " R ",
WhichPiece.Knight => self.IsPromoted ? "^k " : " k ",
WhichPiece.Lance => self.IsPromoted ? "^L " : " L ",
WhichPiece.Pawn => self.IsPromoted ? "^P " : " P ",
_ => " ? ",
};
if (self.Owner == WhichPlayer.Player2)
name = Regex.Replace(name, @"([^\s]+)\s", "$1.");
return name;
}
public static void PrintStateAsAscii(this ShogiBoard self)
{
var builder = new StringBuilder();
builder.Append(" Player 2(.)");
builder.AppendLine();
for (var y = 0; y < 9; 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 = self.Board[x, y];
if (piece == null)
{
builder.Append(" ");
}
else
{
builder.AppendFormat("{0}", piece.GetShortName());
}
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());
}
}
}

309
Gameboard.ShogiUI.UnitTests/Rules/ShogiBoardShould.cs
View File

@@ -1,11 +1,10 @@
using FluentAssertions;
using Gameboard.ShogiUI.Rules;
using Gameboard.ShogiUI.Rules.Pieces;
using Gameboard.ShogiUI.Sockets.Models;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Linq;
using System.Numerics;
using WhichPlayer = Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types.WhichPlayer;
using WhichPiece = Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types.WhichPiece;
namespace Gameboard.ShogiUI.UnitTests.Rules
{
[TestClass]
@@ -15,54 +14,54 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
public void InitializeBoardState()
{
// Assert
var board = new ShogiBoard().Board;
var board = new Shogi().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.Player2);
board[y, x]?.Owner.Should().Be(WhichPlayer.Player2);
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.GoldGeneral);
board[4, 0].WhichPiece.Should().Be(WhichPiece.King);
board[5, 0].WhichPiece.Should().Be(WhichPiece.GoldGeneral);
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[0, 1].WhichPiece.Should().Be(WhichPiece.Knight);
board[0, 2].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[0, 3].WhichPiece.Should().Be(WhichPiece.GoldGeneral);
board[0, 4].WhichPiece.Should().Be(WhichPiece.King);
board[0, 5].WhichPiece.Should().Be(WhichPiece.GoldGeneral);
board[0, 6].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[0, 7].WhichPiece.Should().Be(WhichPiece.Knight);
board[0, 8].WhichPiece.Should().Be(WhichPiece.Lance);
board[1, 0].Should().BeNull();
board[1, 1].WhichPiece.Should().Be(WhichPiece.Rook);
for (var x = 2; x < 7; x++) board[x, 1].Should().BeNull();
board[7, 1].WhichPiece.Should().Be(WhichPiece.Bishop);
board[8, 1].Should().BeNull();
for (var x = 0; x < 9; x++) board[x, 2].WhichPiece.Should().Be(WhichPiece.Pawn);
for (var x = 2; x < 7; x++) board[1, x].Should().BeNull();
board[1, 7].WhichPiece.Should().Be(WhichPiece.Bishop);
board[1, 8].Should().BeNull();
for (var x = 0; x < 9; x++) board[2, x].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();
board[y, x].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.Player1);
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.GoldGeneral);
board[4, 8].WhichPiece.Should().Be(WhichPiece.King);
board[5, 8].WhichPiece.Should().Be(WhichPiece.GoldGeneral);
board[6, 8].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[7, 8].WhichPiece.Should().Be(WhichPiece.Knight);
board[y, x]?.Owner.Should().Be(WhichPlayer.Player1);
board[8, 0].WhichPiece.Should().Be(WhichPiece.Lance);
board[8, 1].WhichPiece.Should().Be(WhichPiece.Knight);
board[8, 2].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[8, 3].WhichPiece.Should().Be(WhichPiece.GoldGeneral);
board[8, 4].WhichPiece.Should().Be(WhichPiece.King);
board[8, 5].WhichPiece.Should().Be(WhichPiece.GoldGeneral);
board[8, 6].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
board[8, 7].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.Bishop);
for (var x = 2; x < 7; x++) board[x, 7].Should().BeNull();
board[7, 0].Should().BeNull();
board[7, 1].WhichPiece.Should().Be(WhichPiece.Bishop);
for (var x = 2; x < 7; x++) board[7, x].Should().BeNull();
board[7, 7].WhichPiece.Should().Be(WhichPiece.Rook);
board[8, 7].Should().BeNull();
for (var x = 0; x < 9; x++) board[x, 6].WhichPiece.Should().Be(WhichPiece.Pawn);
board[7, 8].Should().BeNull();
for (var x = 0; x < 9; x++) board[6, x].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
@@ -70,60 +69,52 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
{
var moves = new[]
{
new Move
{
// Pawn
From = new Vector2(0, 6),
To = new Vector2(0, 5)
}
new Move(new Vector2(0, 6), new Vector2(0, 5))
};
var shogi = new ShogiBoard(moves);
shogi.Board[0, 6].Should().BeNull();
shogi.Board[0, 5].WhichPiece.Should().Be(WhichPiece.Pawn);
var shogi = new Shogi(moves);
shogi.Board[6, 0].Should().BeNull();
shogi.Board[5, 0].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
public void PreventInvalidMoves_MoveFromEmptyPosition()
{
// Arrange
var shogi = new ShogiBoard();
var shogi = new Shogi();
// Prerequisit
shogi.Board[4, 4].Should().BeNull();
// Act
var moveSuccess = shogi.Move(new Move { From = new Vector2(4, 4), To = new Vector2(4, 5) });
var moveSuccess = shogi.Move(new Move(new Vector2(4, 4), new Vector2(4, 5)));
// Assert
moveSuccess.Should().BeFalse();
shogi.Board[4, 4].Should().BeNull();
shogi.Board[4, 5].Should().BeNull();
shogi.Board[5, 4].Should().BeNull();
}
[TestMethod]
public void PreventInvalidMoves_MoveToCurrentPosition()
{
// Arrange
var shogi = new ShogiBoard();
var shogi = new Shogi();
// Act - P1 "moves" pawn to the position it already exists at.
var moveSuccess = shogi.Move(new Move { From = new Vector2(0, 6), To = new Vector2(0, 6) });
var moveSuccess = shogi.Move(new Move(new Vector2(0, 6), new Vector2(0, 6)));
// Assert
moveSuccess.Should().BeFalse();
shogi.Board[0, 6].WhichPiece.Should().Be(WhichPiece.Pawn);
shogi.Board[6, 0].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
public void PreventInvalidMoves_MoveSet()
{
var invalidLanceMove = new Move
{
// Bishop moving lateral
From = new Vector2(1, 1),
To = new Vector2(2, 1)
};
// Bishop moving lateral
var invalidLanceMove = new Move(new Vector2(1, 1), new Vector2(2, 1));
var shogi = new ShogiBoard();
var shogi = new Shogi();
var moveSuccess = shogi.Move(invalidLanceMove);
moveSuccess.Should().BeFalse();
@@ -135,30 +126,26 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
public void PreventInvalidMoves_Ownership()
{
// Arrange
var shogi = new ShogiBoard();
var shogi = new Shogi();
shogi.WhoseTurn.Should().Be(WhichPlayer.Player1);
shogi.Board[8, 2].Owner.Should().Be(WhichPlayer.Player2);
shogi.Board[2, 8].Owner.Should().Be(WhichPlayer.Player2);
// Act - Move Player2 Pawn when it's Player1 turn.
var moveSuccess = shogi.Move(new Move { From = new Vector2(8, 2), To = new Vector2(8, 3) });
var moveSuccess = shogi.Move(new Move(new Vector2(8, 2), new Vector2(8, 3)));
// Assert
moveSuccess.Should().BeFalse();
shogi.Board[8, 6].WhichPiece.Should().Be(WhichPiece.Pawn);
shogi.Board[8, 5].Should().BeNull();
shogi.Board[6, 8].WhichPiece.Should().Be(WhichPiece.Pawn);
shogi.Board[5, 8].Should().BeNull();
}
[TestMethod]
public void PreventInvalidMoves_MoveThroughAllies()
{
var invalidLanceMove = new Move
{
// Lance moving through the pawn before it.
From = new Vector2(0, 8),
To = new Vector2(0, 4)
};
// Lance moving through the pawn before it.
var invalidLanceMove = new Move(new Vector2(0, 8), new Vector2(0, 4));
var shogi = new ShogiBoard();
var shogi = new Shogi();
var moveSuccess = shogi.Move(invalidLanceMove);
moveSuccess.Should().BeFalse();
@@ -169,20 +156,16 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
[TestMethod]
public void PreventInvalidMoves_CaptureAlly()
{
var invalidKnightMove = new Move
{
// Knight capturing allied Pawn
From = new Vector2(1, 8),
To = new Vector2(0, 6)
};
// Knight capturing allied Pawn
var invalidKnightMove = new Move(new Vector2(1, 8), new Vector2(0, 6));
var shogi = new ShogiBoard();
var shogi = new Shogi();
var moveSuccess = shogi.Move(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);
shogi.Board[0, 1].WhichPiece.Should().Be(WhichPiece.Knight);
shogi.Board[2, 0].WhichPiece.Should().Be(WhichPiece.Pawn);
}
[TestMethod]
@@ -192,25 +175,25 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Pawn
new Move { From = new Vector2(2, 6), To = new Vector2(2, 5) },
new Move(new Vector2(2, 6), new Vector2(2, 5)),
// P2 Pawn
new Move { From = new Vector2(6, 2), To = new Vector2(6, 3) },
new Move(new Vector2(6, 2), new Vector2(6, 3)),
// P1 Bishop puts P2 in check
new Move { From = new Vector2(1, 7), To = new Vector2(6, 2) }
new Move(new Vector2(1, 7), new Vector2(6, 2))
};
var shogi = new ShogiBoard(moves);
var shogi = new Shogi(moves);
// Prerequisit
shogi.InCheck.Should().Be(WhichPlayer.Player2);
// Act - P2 moves Lance while remaining in check.
var moveSuccess = shogi.Move(new Move { From = new Vector2(0, 8), To = new Vector2(0, 7) });
var moveSuccess = shogi.Move(new Move(new Vector2(0, 8), new Vector2(0, 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();
shogi.Board[7, 8].Should().BeNull();
}
[TestMethod]
@@ -220,31 +203,31 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Pawn
new Move { From = new Vector2(2, 6), To = new Vector2(2, 5) },
// P2 Pawn
new Move { From = new Vector2(0, 2), To = new Vector2(0, 3) },
new Move(new Vector2(2, 6), new Vector2(2, 5) ),
// P2 Pawn
new Move(new Vector2(0, 2), new Vector2(0, 3) ),
// P1 Bishop takes P2 Pawn
new Move { From = new Vector2(1, 7), To = new Vector2(6, 2) },
new Move(new Vector2(1, 7), new Vector2(6, 2) ),
// P2 Gold, block check from P1 Bishop.
new Move { From = new Vector2(5, 0), To = new Vector2(5, 1) },
new Move(new Vector2(5, 0), new Vector2(5, 1) ),
// P1 Bishop takes P2 Bishop, promotes so it can capture P2 Knight and P2 Lance
new Move { From = new Vector2(6, 2), To = new Vector2(7, 1), IsPromotion = true },
new Move(new Vector2(6, 2), new Vector2(7, 1), true ),
// P2 Pawn again
new Move { From = new Vector2(0, 3), To = new Vector2(0, 4) },
new Move(new Vector2(0, 3), new Vector2(0, 4) ),
// P1 Bishop takes P2 Knight
new Move { From = new Vector2(7, 1), To = new Vector2(7, 0) },
new Move(new Vector2(7, 1), new Vector2(7, 0) ),
// P2 Pawn again
new Move { From = new Vector2(0, 4), To = new Vector2(0, 5) },
new Move(new Vector2(0, 4), new Vector2(0, 5) ),
// P1 Bishop takes P2 Lance
new Move { From = new Vector2(7, 0), To = new Vector2(8, 0) },
new Move(new Vector2(7, 0), new Vector2(8, 0) ),
// P2 Lance (move to make room for attempted P1 Pawn placement)
new Move { From = new Vector2(0, 0), To = new Vector2(0, 1) },
new Move(new Vector2(0, 0), new Vector2(0, 1) ),
// P1 arbitrary move
new Move { From = new Vector2(4, 8), To = new Vector2(4, 7) },
new Move(new Vector2(4, 8), new Vector2(4, 7) ),
// P2 Pawn again, takes P1 Pawn
new Move { From = new Vector2(0, 5), To = new Vector2(0, 6) },
new Move(new Vector2(0, 5) , new Vector2(0, 6) ),
};
var shogi = new ShogiBoard(moves);
var shogi = new Shogi(moves);
// Prerequisites
shogi.Hands[WhichPlayer.Player1].Count.Should().Be(4);
@@ -255,27 +238,27 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
// Act | Assert - It is P1 turn
/// try illegally placing Knight from the hand.
shogi.Board[7, 0].Should().BeNull();
var dropSuccess = shogi.Move(new Move { PieceFromHand = WhichPiece.Knight, To = new Vector2(7, 0) });
shogi.Board[0, 7].Should().BeNull();
var dropSuccess = shogi.Move(new Move(WhichPiece.Knight, new Vector2(7, 0)));
dropSuccess.Should().BeFalse();
shogi.Hands[WhichPlayer.Player1].Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Lance);
shogi.Board[7, 0].Should().BeNull();
dropSuccess = shogi.Move(new Move { PieceFromHand = WhichPiece.Knight, To = new Vector2(7, 1) });
shogi.Board[0, 7].Should().BeNull();
dropSuccess = shogi.Move(new Move(WhichPiece.Knight, new Vector2(7, 1)));
dropSuccess.Should().BeFalse();
shogi.Hands[WhichPlayer.Player1].Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Lance);
shogi.Board[7, 1].Should().BeNull();
shogi.Board[1, 7].Should().BeNull();
/// try illegally placing Pawn from the hand
dropSuccess = shogi.Move(new Move { PieceFromHand = WhichPiece.Pawn, To = new Vector2(7, 0) });
dropSuccess = shogi.Move(new Move(WhichPiece.Pawn, new Vector2(7, 0)));
dropSuccess.Should().BeFalse();
shogi.Hands[WhichPlayer.Player1].Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Pawn);
shogi.Board[7, 0].Should().BeNull();
shogi.Board[0, 7].Should().BeNull();
/// try illegally placing Lance from the hand
dropSuccess = shogi.Move(new Move { PieceFromHand = WhichPiece.Lance, To = new Vector2(7, 0) });
dropSuccess = shogi.Move(new Move(WhichPiece.Lance, new Vector2(7, 0)));
dropSuccess.Should().BeFalse();
shogi.Hands[WhichPlayer.Player1].Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Lance);
shogi.Board[7, 0].Should().BeNull();
shogi.Board[0, 7].Should().BeNull();
}
[TestMethod]
@@ -285,34 +268,34 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Pawn
new Move { From = new Vector2(2, 6), To = new Vector2(2, 5) },
// P2 Pawn
new Move { From = new Vector2(8, 2), To = new Vector2(8, 3) },
new Move(new Vector2(2, 6), new Vector2(2, 5)),
// P2 Pawn
new Move(new Vector2(8, 2), new Vector2(8, 3)),
// P1 Bishop, check
new Move { From = new Vector2(1, 7), To = new Vector2(6, 2) },
new Move(new Vector2(1, 7), new Vector2(6, 2)),
// P2 Gold, block check
new Move { From = new Vector2(5, 0), To = new Vector2(5, 1) },
new Move(new Vector2(5, 0), new Vector2(5, 1)),
// P1 arbitrary move
new Move { From = new Vector2(0, 6), To = new Vector2(0, 5) },
new Move(new Vector2(0, 6), new Vector2(0, 5)),
// P2 Bishop
new Move { From = new Vector2(7, 1), To = new Vector2(8, 2) },
new Move(new Vector2(7, 1), new Vector2(8, 2)),
// P1 Bishop takes P2 Lance
new Move { From = new Vector2(6, 2), To = new Vector2(8, 0) },
new Move(new Vector2(6, 2), new Vector2(8, 0)),
// P2 Bishop
new Move { From = new Vector2(8, 2), To = new Vector2(7, 1) },
new Move(new Vector2(8, 2), new Vector2(7, 1)),
// P1 arbitrary move
new Move { From = new Vector2(0, 5), To = new Vector2(0, 4) },
new Move(new Vector2(0, 5), new Vector2(0, 4)),
// P2 Bishop, check
new Move { From = new Vector2(7, 1), To = new Vector2(2, 6) },
new Move(new Vector2(7, 1), new Vector2(2, 6)),
};
var shogi = new ShogiBoard(moves);
var shogi = new Shogi(moves);
// Prerequisites
shogi.InCheck.Should().Be(WhichPlayer.Player1);
shogi.Hands[WhichPlayer.Player1].Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Lance);
// Act - P1 tries to place a Lance while in check.
var dropSuccess = shogi.Move(new Move { PieceFromHand = WhichPiece.Lance, To = new Vector2(4, 4) });
var dropSuccess = shogi.Move(new Move(WhichPiece.Lance, new Vector2(4, 4)));
// Assert
dropSuccess.Should().BeFalse();
@@ -328,31 +311,31 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Pawn
new Move { From = new Vector2(2, 6), To = new Vector2(2, 5) },
// P2 Pawn
new Move { From = new Vector2(6, 2), To = new Vector2(6, 3) },
new Move(new Vector2(2, 6), new Vector2(2, 5)),
// P2 Pawn
new Move(new Vector2(6, 2), new Vector2(6, 3)),
// P1 Bishop, capture P2 Pawn, check
new Move { From = new Vector2(1, 7), To = new Vector2(6, 2) },
new Move(new Vector2(1, 7), new Vector2(6, 2)),
// P2 Gold, block check
new Move { From = new Vector2(5, 0), To = new Vector2(5, 1) },
new Move(new Vector2(5, 0), new Vector2(5, 1)),
// P1 Bishop capture P2 Bishop
new Move { From = new Vector2(6, 2), To = new Vector2(7, 1) },
new Move(new Vector2(6, 2), new Vector2(7, 1)),
// P2 arbitrary move
new Move { From = new Vector2(0, 0), To = new Vector2(0, 1) },
new Move(new Vector2(0, 0), new Vector2(0, 1)),
};
var shogi = new ShogiBoard(moves);
var shogi = new Shogi(moves);
// Prerequisites
shogi.Hands[WhichPlayer.Player1].Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Bishop);
shogi.Board[4, 0].Should().NotBeNull();
shogi.Board[0, 4].Should().NotBeNull();
// Act - P1 tries to place Bishop from hand to an already-occupied position
var dropSuccess = shogi.Move(new Move { PieceFromHand = WhichPiece.Bishop, To = new Vector2(4, 0) });
var dropSuccess = shogi.Move(new Move(WhichPiece.Bishop, new Vector2(4, 0)));
// Assert
dropSuccess.Should().BeFalse();
shogi.Hands[WhichPlayer.Player1].Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Bishop);
shogi.Board[4, 0].WhichPiece.Should().Be(WhichPiece.King);
shogi.Board[0, 4].WhichPiece.Should().Be(WhichPiece.King);
}
[TestMethod]
@@ -362,14 +345,14 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Pawn
new Move { From = new Vector2(2, 6), To = new Vector2(2, 5) },
// P2 Pawn
new Move { From = new Vector2(6, 2), To = new Vector2(6, 3) },
new Move(new Vector2(2, 6), new Vector2(2, 5) ),
// P2 Pawn
new Move(new Vector2(6, 2), new Vector2(6, 3) ),
};
var shogi = new ShogiBoard(moves);
var shogi = new Shogi(moves);
// Act - P1 Bishop, check
shogi.Move(new Move { From = new Vector2(1, 7), To = new Vector2(6, 2) });
shogi.Move(new Move(new Vector2(1, 7), new Vector2(6, 2)));
// Assert
shogi.InCheck.Should().Be(WhichPlayer.Player2);
@@ -382,14 +365,14 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Pawn
new Move { From = new Vector2(2, 6), To = new Vector2(2, 5) },
new Move(new Vector2(2, 6), new Vector2(2, 5)),
// P2 Pawn
new Move { From = new Vector2(6, 2), To = new Vector2(6, 3) }
new Move(new Vector2(6, 2), new Vector2(6, 3))
};
var shogi = new ShogiBoard(moves);
var shogi = new Shogi(moves);
// Act - P1 Bishop captures P2 Bishop
var moveSuccess = shogi.Move(new Move { From = new Vector2(1, 7), To = new Vector2(7, 1) });
var moveSuccess = shogi.Move(new Move(new Vector2(1, 7), new Vector2(7, 1)));
// Assert
moveSuccess.Should().BeTrue();
@@ -398,20 +381,20 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
.Count(piece => piece?.WhichPiece == WhichPiece.Bishop)
.Should()
.Be(1);
shogi.Board[1, 7].Should().BeNull();
shogi.Board[7, 1].WhichPiece.Should().Be(WhichPiece.Bishop);
shogi.Board[7, 1].Should().BeNull();
shogi.Board[1, 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.Move(new Move { From = new Vector2(6, 0), To = new Vector2(7, 1) });
moveSuccess = shogi.Move(new Move(new Vector2(6, 0), new Vector2(7, 1)));
// Assert
moveSuccess.Should().BeTrue();
shogi.Board[6, 0].Should().BeNull();
shogi.Board[7, 1].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
shogi.Board[0, 6].Should().BeNull();
shogi.Board[1, 7].WhichPiece.Should().Be(WhichPiece.SilverGeneral);
shogi.Board
.Cast<Piece>()
.Count(piece => piece?.WhichPiece == WhichPiece.Bishop)
@@ -428,19 +411,19 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Pawn
new Move { From = new Vector2(2, 6), To = new Vector2(2, 5) },
// P2 Pawn
new Move { From = new Vector2(6, 2), To = new Vector2(6, 3) }
};
var shogi = new ShogiBoard(moves);
new Move(new Vector2(2, 6), new Vector2(2, 5) ),
// P2 Pawn
new Move(new Vector2(6, 2), new Vector2(6, 3) )
};
var shogi = new Shogi(moves);
// Act - P1 moves across promote threshold.
var moveSuccess = shogi.Move(new Move { From = new Vector2(1, 7), To = new Vector2(6, 2), IsPromotion = true });
var moveSuccess = shogi.Move(new Move(new Vector2(1, 7), new Vector2(6, 2), true));
// Assert
moveSuccess.Should().BeTrue();
shogi.Board[1, 7].Should().BeNull();
shogi.Board[6, 2].Should().Match<Piece>(piece => piece.WhichPiece == WhichPiece.Bishop && piece.IsPromoted == true);
shogi.Board[7, 1].Should().BeNull();
shogi.Board[2, 6].Should().Match<Piece>(piece => piece.WhichPiece == WhichPiece.Bishop && piece.IsPromoted == true);
}
[TestMethod]
@@ -450,30 +433,30 @@ namespace Gameboard.ShogiUI.UnitTests.Rules
var moves = new[]
{
// P1 Rook
new Move { From = new Vector2(7, 7), To = new Vector2(4, 7) },
new Move(new Vector2(7, 7), new Vector2(4, 7) ),
// P2 Gold
new Move { From = new Vector2(3, 0), To = new Vector2(2, 1) },
new Move(new Vector2(3, 0), new Vector2(2, 1) ),
// P1 Pawn
new Move { From = new Vector2(4, 6), To = new Vector2(4, 5) },
new Move(new Vector2(4, 6), new Vector2(4, 5) ),
// P2 other Gold
new Move { From = new Vector2(5, 0), To = new Vector2(6, 1) },
new Move(new Vector2(5, 0), new Vector2(6, 1) ),
// P1 same Pawn
new Move { From = new Vector2(4, 5), To = new Vector2(4, 4) },
new Move(new Vector2(4, 5), new Vector2(4, 4) ),
// P2 Pawn
new Move { From = new Vector2(4, 2), To = new Vector2(4, 3) },
new Move(new Vector2(4, 2), new Vector2(4, 3) ),
// P1 Pawn takes P2 Pawn
new Move { From = new Vector2(4, 4), To = new Vector2(4, 3) },
new Move(new Vector2(4, 4), new Vector2(4, 3) ),
// P2 King
new Move { From = new Vector2(4, 0), To = new Vector2(4, 1) },
new Move(new Vector2(4, 0), new Vector2(4, 1) ),
// P1 Pawn promotes, threatens P2 King
new Move { From = new Vector2(4, 3), To = new Vector2(4, 2), IsPromotion = true },
new Move(new Vector2(4, 3), new Vector2(4, 2), true ),
// P2 King retreat
new Move { From = new Vector2(4, 1), To = new Vector2(4, 0) },
new Move(new Vector2(4, 1), new Vector2(4, 0) ),
};
var shogi = new ShogiBoard(moves);
var shogi = new Shogi(moves);
// Act - P1 Pawn wins by checkmate.
var moveSuccess = shogi.Move(new Move { From = new Vector2(4, 2), To = new Vector2(4, 1) });
var moveSuccess = shogi.Move(new Move(new Vector2(4, 2), new Vector2(4, 1)));
// Assert - checkmate
moveSuccess.Should().BeTrue();

27
Gameboard.ShogiUI.UnitTests/Sockets/CoordsModelShould.cs
View File

@@ -1,27 +0,0 @@
using FluentAssertions;
using Gameboard.ShogiUI.Sockets.Models;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Gameboard.ShogiUI.UnitTests.Sockets
{
[TestClass]
public class CoordsModelShould
{
[TestMethod]
public void ConvertToNotation()
{
var letters = "ABCDEFGHI";
for (var x = 0; x < 8; x++) // file
{
for (var y = 0; y < 8; y++) // rank
{
var move = new Coords(x, y);
var actual = move.ToBoardNotation();
var expected = $"{letters[x]}{y + 1}";
actual.Should().Be(expected);
}
}
}
}
}