// move *your* peice
private bool IsMovable(
BPiece piece, Coord to, bool isDrop, Coord?dropTo)
{
if (piece == null)
{
return(false);
}
// failFlag is used for tell onFailure() is called in CheckIf funcitons
bool failFlag = false;
Coord from;
if (isDrop)
{
if (!dropTo.HasValue)
{
Trace.TraceError("dropFrom cannot be null when isDrop == true");
Environment.Exit(1);
}
from = dropTo.Value;
}
else
{
CheckIfMapContains(piece, () => failFlag = false);
if (failFlag)
{
return(false);
}
from = GetCoord(piece);
}
CheckIfCoordIsOnBoard(from, () => failFlag = true);
CheckIfCoordIsOnBoard(to, () => failFlag = true);
if (failFlag)
{
return(false);
}
// cannot move to outside of the control
if (!piece.HasControlTo(to - from))
{
return(false);
}
// cannot move onto your piece
if (GetPiece(to) != null && GetPiece(to).White == piece.White)
{
return(false);
}
// cannot move over pieces, except for non-promoted knight
if ((from.Row == to.Row || from.Col == to.Col) &&
!piece.CanJump() &&
!this.IsEmptyBetween(from, to))
{
return(false);
}
return(true);
}
public void NG_ShouldNotPromoteTwice(EPieceSort sort)
{
BPiece piece = MakePiece(sort, true);
piece.Promote();
Assert.IsFalse(piece.CanPromote(), $"{sort} must not promote twice");
}
// overwrite is not allowed
private bool SetCoordByPiece(BPiece piece, Coord coord)
{
CheckIfCoordIsOnBoard(coord);
CheckIfMapIsEmptyFor(piece);
_pieceCoordMap.Add(piece, coord);
return(true);
}
public void NG_AnyNonPromotedPieceShouldNotHaveControlToItself(
EPieceSort sort, bool isWhite)
{
BPiece piece = MakePiece(sort, isWhite);
Assert.IsFalse(piece.HasControlTo(Coord.Zero),
$"{piece} should not have control to itself");
}
public void OK_EveryPieceShouldBeNonPromotedAtFirst(
[Values] EPieceSort sort,
[Values] bool isWhtie
)
{
BPiece piece = MakePiece(sort, isWhtie);
Assert.IsFalse(piece.Promoted, "Every piece should not be non-promoted at first");
}
/// <summary>
/// Drop the piece to specified coordinate.
/// </summary>
/// <param name="piece">Piece that is dropped.</param>
/// <param name="dropTo">where the piece is dropped.</param>
public void Drop(BPiece piece, Coord dropTo)
{
if (!IsDropable(piece, dropTo))
{
Trace.TraceError($"couldn't drop {piece} to {dropTo}");
Environment.Exit(1);
}
SetPieceByCoord(piece, dropTo);
SetCoordByPiece(piece, dropTo);
}
// overwrite is not allowed
private bool SetPieceByCoord(BPiece piece, Coord coord)
{
CheckIfCoordIsOnBoard(coord);
if (GetPiece(coord) != null)
{
Trace.TraceError($"error: Board{coord} is already occupied.");
return(false);
}
_pieceList[CalcPiecesIndex(coord)] = piece;
return(true);
}
public void Init()
{
Console.WriteLine("Shogi#Init() called");
// TODO: 誰がPieceをNewするのか？誰がPieceインスタンスを管理するのか？Pieceインスタンスの総数は固定したい
BPiece gold = PieceFactory.MakePiece(EPieceSort.kGold, true);
BPiece king = PieceFactory.MakePiece(EPieceSort.kKing, false);
Board.Drop(gold, new Coord(8, 4));
Board.Drop(king, new Coord(0, 4));
Turn.Switch();
}
private void CheckIfMapIsEmptyFor(BPiece piece, Action onFailure = null)
{
if (onFailure == null)
{
onFailure = defaultOnFailure;
}
if (_pieceCoordMap.ContainsKey(piece))
{
Trace.TraceError($"{nameof(_pieceCoordMap)} for {piece} is already occupied");
onFailure();
}
}
private void CheckIfMapContains(BPiece piece, Action onFailure = null)
{
if (onFailure == null)
{
onFailure = defaultOnFailure;
}
if (!_pieceCoordMap.ContainsKey(piece))
{
Trace.TraceError($"{nameof(_pieceCoordMap)} does not contains {piece}");
onFailure();
}
}
private bool RemoveCoordByPiece(BPiece piece)
{
if (!_pieceCoordMap.ContainsKey(piece))
{
return(false);
}
else
{
_pieceCoordMap.Remove(piece);
return(true);
}
}
private void RenderPiece(BPiece piece)
{
if (piece == null)
{
Write("..");
return;
}
if (piece.Promoted)
{
Write("!");
}
else
{
Write(".");
}
switch (piece.Sort)
{
case EPieceSort.kKing:
Write((piece.White ? "K" : "k"));
break;
case EPieceSort.kRook:
Write((piece.White ? "R" : "r"));
break;
case EPieceSort.kBishop:
Write((piece.White ? "B" : "b"));
break;
case EPieceSort.kGold:
Write((piece.White ? "G" : "g"));
break;
case EPieceSort.kSilver:
Write((piece.White ? "S" : "s"));
break;
case EPieceSort.kKnight:
Write((piece.White ? "N" : "n"));
break;
case EPieceSort.kLance:
Write((piece.White ? "L" : "l"));
break;
case EPieceSort.kPorn:
Write((piece.White ? "P" : "p"));
break;
}
}
/// <summary>
/// Moves the specified piece.
/// </summary>
/// <returns>Taken piece, if this move takes.</returns>
/// <param name="piece">Piece that is moved.</param>
/// <param name="to">Coordinate the piece is moved to.</param>
public BPiece Move(BPiece piece, Coord to)
{
if (!IsMovable(piece, to))
{
Trace.TraceError($"board cannnot move {piece} from {GetCoord(piece)} to {to}");
Environment.Exit(1);
}
BPiece toPiece = GetPiece(to);
if (toPiece != null)
{
// this move takes a opponent's piece.
Debug.Assert(toPiece.White != piece.White);
RemovePieceByCoord(GetCoord(toPiece));
RemoveCoordByPiece(toPiece);
}
RemovePieceByCoord(GetCoord(piece));
RemoveCoordByPiece(piece);
SetCoordByPiece(piece, to);
SetPieceByCoord(piece, to);
return(toPiece);
}
private bool IsDropable(BPiece piece, Coord dropTo)
{
bool failFlag = false;
CheckIfCoordIsOnBoard(dropTo, () => failFlag = true);
if (failFlag)
{
return(false);
}
// TODO: Optimization
foreach (int i in Enumerable.Range(0, kSize.Row))
{
foreach (int j in Enumerable.Range(0, kSize.Col))
{
if (IsMovable(piece, new Coord(i, j), true, dropTo) &&
GetPiece(dropTo) == null)
{
return(true);
}
}
}
return(false);
}
public void OK_ShouldPromote(EPieceSort sort)
{
BPiece piece = MakePiece(sort, true);
Assert.IsTrue(piece.CanPromote(), $"{sort} should promote");
}
/// <summary>
/// Gets the coordinate by piece.
/// </summary>
/// <returns>The coordinate.</returns>
/// <param name="piece">Piece.</param>
public Coord GetCoord(BPiece piece)
{
CheckIfMapContains(piece);
return(_pieceCoordMap[piece]);
}
private bool IsMovable(BPiece piece, Coord to) => IsMovable(piece, to, false, null);
public void OK_ShouldJump(EPieceSort sort)
{
BPiece piece = MakePiece(sort, true);
Assert.IsTrue(piece.CanJump(), $"{sort} should jump");
}
public void NG_ShouldNotJump(EPieceSort sort)
{
BPiece piece = MakePiece(sort, true);
Assert.IsFalse(piece.CanJump(), $"{sort} must not jump");
}
/// <summary>
/// Checks if the piece can promote,
/// including information about the board and the piece.
/// </summary>
/// <returns><c>true</c>, if promote was caned, <c>false</c> otherwise.</returns>
/// <param name="piece">Piece.</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
public bool CanPromote(BPiece piece, Coord from, Coord to)
{
return(piece.CanPromote() &&
(IsWithinOpponentsField(piece.White, from) ||
IsWithinOpponentsField(piece.White, to)));
}
