convert to blazor server side render

2025-12-24 16:43:51 -06:00
parent 357c3d9932
commit dcbf8a3ac3
215 changed files with 1867 additions and 2350 deletions
--- a/Tests/UnitTests/ShogiBoardStateShould.cs
+++ b/Tests/UnitTests/ShogiBoardStateShould.cs
@@ -1,4 +1,4 @@
-using Shogi.Domain.ValueObjects;
+using Shogi.Domains.ValueObjects;

 namespace UnitTests;

@@ -11,174 +11,174 @@ public class ShogiBoardStateShould
 		var board = BoardState.StandardStarting;

 		// Assert
-		board["A1"]!.WhichPiece.Should().Be(WhichPiece.Lance);
-		board["A1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["A1"]!.IsPromoted.Should().Be(false);
-		board["B1"]!.WhichPiece.Should().Be(WhichPiece.Knight);
-		board["B1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["B1"]!.IsPromoted.Should().Be(false);
-		board["C1"]!.WhichPiece.Should().Be(WhichPiece.SilverGeneral);
-		board["C1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["C1"]!.IsPromoted.Should().Be(false);
-		board["D1"]!.WhichPiece.Should().Be(WhichPiece.GoldGeneral);
-		board["D1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["D1"]!.IsPromoted.Should().Be(false);
-		board["E1"]!.WhichPiece.Should().Be(WhichPiece.King);
-		board["E1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["E1"]!.IsPromoted.Should().Be(false);
-		board["F1"]!.WhichPiece.Should().Be(WhichPiece.GoldGeneral);
-		board["F1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["F1"]!.IsPromoted.Should().Be(false);
-		board["G1"]!.WhichPiece.Should().Be(WhichPiece.SilverGeneral);
-		board["G1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["G1"]!.IsPromoted.Should().Be(false);
-		board["H1"]!.WhichPiece.Should().Be(WhichPiece.Knight);
-		board["H1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["H1"]!.IsPromoted.Should().Be(false);
-		board["I1"]!.WhichPiece.Should().Be(WhichPiece.Lance);
-		board["I1"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["I1"]!.IsPromoted.Should().Be(false);
+		Assert.Equal(WhichPiece.Lance, board["A1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["A1"]!.Owner);
+		Assert.False(board["A1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Knight, board["B1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["B1"]!.Owner);
+		Assert.False(board["B1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.SilverGeneral, board["C1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["C1"]!.Owner);
+		Assert.False(board["C1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.GoldGeneral, board["D1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["D1"]!.Owner);
+		Assert.False(board["D1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.King, board["E1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["E1"]!.Owner);
+		Assert.False(board["E1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.GoldGeneral, board["F1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["F1"]!.Owner);
+		Assert.False(board["F1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.SilverGeneral, board["G1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["G1"]!.Owner);
+		Assert.False(board["G1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Knight, board["H1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["H1"]!.Owner);
+		Assert.False(board["H1"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Lance, board["I1"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["I1"]!.Owner);
+		Assert.False(board["I1"]!.IsPromoted);

-		board["A2"].Should().BeNull();
-		board["B2"]!.WhichPiece.Should().Be(WhichPiece.Bishop);
-		board["B2"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["B2"]!.IsPromoted.Should().Be(false);
-		board["C2"].Should().BeNull();
-		board["D2"].Should().BeNull();
-		board["E2"].Should().BeNull();
-		board["F2"].Should().BeNull();
-		board["G2"].Should().BeNull();
-		board["H2"]!.WhichPiece.Should().Be(WhichPiece.Rook);
-		board["H2"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["H2"]!.IsPromoted.Should().Be(false);
-		board["I2"].Should().BeNull();
+		Assert.Null(board["A2"]);
+		Assert.Equal(WhichPiece.Bishop, board["B2"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["B2"]!.Owner);
+		Assert.False(board["B2"]!.IsPromoted);
+		Assert.Null(board["C2"]);
+		Assert.Null(board["D2"]);
+		Assert.Null(board["E2"]);
+		Assert.Null(board["F2"]);
+		Assert.Null(board["G2"]);
+		Assert.Equal(WhichPiece.Rook, board["H2"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["H2"]!.Owner);
+		Assert.False(board["H2"]!.IsPromoted);
+		Assert.Null(board["I2"]);

-		board["A3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["A3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["A3"]!.IsPromoted.Should().Be(false);
-		board["B3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["B3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["B3"]!.IsPromoted.Should().Be(false);
-		board["C3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["C3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["C3"]!.IsPromoted.Should().Be(false);
-		board["D3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["D3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["D3"]!.IsPromoted.Should().Be(false);
-		board["E3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["E3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["E3"]!.IsPromoted.Should().Be(false);
-		board["F3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["F3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["F3"]!.IsPromoted.Should().Be(false);
-		board["G3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["G3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["G3"]!.IsPromoted.Should().Be(false);
-		board["H3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["H3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["H3"]!.IsPromoted.Should().Be(false);
-		board["I3"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["I3"]!.Owner.Should().Be(WhichPlayer.Player1);
-		board["I3"]!.IsPromoted.Should().Be(false);
+		Assert.Equal(WhichPiece.Pawn, board["A3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["A3"]!.Owner);
+		Assert.False(board["A3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["B3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["B3"]!.Owner);
+		Assert.False(board["B3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["C3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["C3"]!.Owner);
+		Assert.False(board["C3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["D3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["D3"]!.Owner);
+		Assert.False(board["D3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["E3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["E3"]!.Owner);
+		Assert.False(board["E3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["F3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["F3"]!.Owner);
+		Assert.False(board["F3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["G3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["G3"]!.Owner);
+		Assert.False(board["G3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["H3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["H3"]!.Owner);
+		Assert.False(board["H3"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["I3"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player1, board["I3"]!.Owner);
+		Assert.False(board["I3"]!.IsPromoted);

-		board["A4"].Should().BeNull();
-		board["B4"].Should().BeNull();
-		board["C4"].Should().BeNull();
-		board["D4"].Should().BeNull();
-		board["E4"].Should().BeNull();
-		board["F4"].Should().BeNull();
-		board["G4"].Should().BeNull();
-		board["H4"].Should().BeNull();
-		board["I4"].Should().BeNull();
+		Assert.Null(board["A4"]);
+		Assert.Null(board["B4"]);
+		Assert.Null(board["C4"]);
+		Assert.Null(board["D4"]);
+		Assert.Null(board["E4"]);
+		Assert.Null(board["F4"]);
+		Assert.Null(board["G4"]);
+		Assert.Null(board["H4"]);
+		Assert.Null(board["I4"]);

-		board["A5"].Should().BeNull();
-		board["B5"].Should().BeNull();
-		board["C5"].Should().BeNull();
-		board["D5"].Should().BeNull();
-		board["E5"].Should().BeNull();
-		board["F5"].Should().BeNull();
-		board["G5"].Should().BeNull();
-		board["H5"].Should().BeNull();
-		board["I5"].Should().BeNull();
+		Assert.Null(board["A5"]);
+		Assert.Null(board["B5"]);
+		Assert.Null(board["C5"]);
+		Assert.Null(board["D5"]);
+		Assert.Null(board["E5"]);
+		Assert.Null(board["F5"]);
+		Assert.Null(board["G5"]);
+		Assert.Null(board["H5"]);
+		Assert.Null(board["I5"]);

-		board["A6"].Should().BeNull();
-		board["B6"].Should().BeNull();
-		board["C6"].Should().BeNull();
-		board["D6"].Should().BeNull();
-		board["E6"].Should().BeNull();
-		board["F6"].Should().BeNull();
-		board["G6"].Should().BeNull();
-		board["H6"].Should().BeNull();
-		board["I6"].Should().BeNull();
+		Assert.Null(board["A6"]);
+		Assert.Null(board["B6"]);
+		Assert.Null(board["C6"]);
+		Assert.Null(board["D6"]);
+		Assert.Null(board["E6"]);
+		Assert.Null(board["F6"]);
+		Assert.Null(board["G6"]);
+		Assert.Null(board["H6"]);
+		Assert.Null(board["I6"]);

-		board["A7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["A7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["A7"]!.IsPromoted.Should().Be(false);
-		board["B7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["B7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["B7"]!.IsPromoted.Should().Be(false);
-		board["C7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["C7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["C7"]!.IsPromoted.Should().Be(false);
-		board["D7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["D7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["D7"]!.IsPromoted.Should().Be(false);
-		board["E7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["E7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["E7"]!.IsPromoted.Should().Be(false);
-		board["F7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["F7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["F7"]!.IsPromoted.Should().Be(false);
-		board["G7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["G7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["G7"]!.IsPromoted.Should().Be(false);
-		board["H7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["H7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["H7"]!.IsPromoted.Should().Be(false);
-		board["I7"]!.WhichPiece.Should().Be(WhichPiece.Pawn);
-		board["I7"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["I7"]!.IsPromoted.Should().Be(false);
+		Assert.Equal(WhichPiece.Pawn, board["A7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["A7"]!.Owner);
+		Assert.False(board["A7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["B7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["B7"]!.Owner);
+		Assert.False(board["B7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["C7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["C7"]!.Owner);
+		Assert.False(board["C7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["D7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["D7"]!.Owner);
+		Assert.False(board["D7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["E7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["E7"]!.Owner);
+		Assert.False(board["E7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["F7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["F7"]!.Owner);
+		Assert.False(board["F7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["G7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["G7"]!.Owner);
+		Assert.False(board["G7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["H7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["H7"]!.Owner);
+		Assert.False(board["H7"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Pawn, board["I7"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["I7"]!.Owner);
+		Assert.False(board["I7"]!.IsPromoted);

-		board["A8"].Should().BeNull();
-		board["B8"]!.WhichPiece.Should().Be(WhichPiece.Rook);
-		board["B8"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["B8"]!.IsPromoted.Should().Be(false);
-		board["C8"].Should().BeNull();
-		board["D8"].Should().BeNull();
-		board["E8"].Should().BeNull();
-		board["F8"].Should().BeNull();
-		board["G8"].Should().BeNull();
-		board["H8"]!.WhichPiece.Should().Be(WhichPiece.Bishop);
-		board["H8"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["H8"]!.IsPromoted.Should().Be(false);
-		board["I8"].Should().BeNull();
+		Assert.Null(board["A8"]);
+		Assert.Equal(WhichPiece.Rook, board["B8"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["B8"]!.Owner);
+		Assert.False(board["B8"]!.IsPromoted);
+		Assert.Null(board["C8"]);
+		Assert.Null(board["D8"]);
+		Assert.Null(board["E8"]);
+		Assert.Null(board["F8"]);
+		Assert.Null(board["G8"]);
+		Assert.Equal(WhichPiece.Bishop, board["H8"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["H8"]!.Owner);
+		Assert.False(board["H8"]!.IsPromoted);
+		Assert.Null(board["I8"]);

-		board["A9"]!.WhichPiece.Should().Be(WhichPiece.Lance);
-		board["A9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["A9"]!.IsPromoted.Should().Be(false);
-		board["B9"]!.WhichPiece.Should().Be(WhichPiece.Knight);
-		board["B9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["B9"]!.IsPromoted.Should().Be(false);
-		board["C9"]!.WhichPiece.Should().Be(WhichPiece.SilverGeneral);
-		board["C9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["C9"]!.IsPromoted.Should().Be(false);
-		board["D9"]!.WhichPiece.Should().Be(WhichPiece.GoldGeneral);
-		board["D9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["D9"]!.IsPromoted.Should().Be(false);
-		board["E9"]!.WhichPiece.Should().Be(WhichPiece.King);
-		board["E9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["E9"]!.IsPromoted.Should().Be(false);
-		board["F9"]!.WhichPiece.Should().Be(WhichPiece.GoldGeneral);
-		board["F9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["F9"]!.IsPromoted.Should().Be(false);
-		board["G9"]!.WhichPiece.Should().Be(WhichPiece.SilverGeneral);
-		board["G9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["G9"]!.IsPromoted.Should().Be(false);
-		board["H9"]!.WhichPiece.Should().Be(WhichPiece.Knight);
-		board["H9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["H9"]!.IsPromoted.Should().Be(false);
-		board["I9"]!.WhichPiece.Should().Be(WhichPiece.Lance);
-		board["I9"]!.Owner.Should().Be(WhichPlayer.Player2);
-		board["I9"]!.IsPromoted.Should().Be(false);
+		Assert.Equal(WhichPiece.Lance, board["A9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["A9"]!.Owner);
+		Assert.False(board["A9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Knight, board["B9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["B9"]!.Owner);
+		Assert.False(board["B9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.SilverGeneral, board["C9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["C9"]!.Owner);
+		Assert.False(board["C9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.GoldGeneral, board["D9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["D9"]!.Owner);
+		Assert.False(board["D9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.King, board["E9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["E9"]!.Owner);
+		Assert.False(board["E9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.GoldGeneral, board["F9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["F9"]!.Owner);
+		Assert.False(board["F9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.SilverGeneral, board["G9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["G9"]!.Owner);
+		Assert.False(board["G9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Knight, board["H9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["H9"]!.Owner);
+		Assert.False(board["H9"]!.IsPromoted);
+		Assert.Equal(WhichPiece.Lance, board["I9"]!.WhichPiece);
+		Assert.Equal(WhichPlayer.Player2, board["I9"]!.Owner);
+		Assert.False(board["I9"]!.IsPromoted);
 	}
 }