/// <summary>
/// The CanMoveDown
/// </summary>
/// <param name="piece">The piece<see cref="Piece"/></param>
/// <returns>The <see cref="bool"/></returns>
private bool CanMoveDown(Piece piece)
{
if (!State.CanMove)
{
return(false);
}
var newPosition = new Point(piece.Position.X, piece.Position.Y + 1);
var testPiece = new PieceBuilder()
.OfType(piece.Type)
.OnPosition(newPosition)
.WithRotation(piece.Rotation)
.OnBoard(this)
.Build();
//check if current piece's blocks don't go out the board height edge
foreach (var i in testPiece.Blocks)
{
if (i.Y > Dimension.Height - 1)
{
return(false);
}
}
return(!ThereIsCollision(testPiece));
}
public void SetCorrectPiecePos(GameObject _pieceObj, int _id, float _duration)
{
PieceBuilder _piece = _pieceObj.GetComponent <PieceBuilder>();
Vector3 _correctPos = listAnswerForSample.Find(a => a.x == _id);
if (_correctPos != null)
{
_piece.AutoCorrectPiece(new Vector2(_correctPos.y, _correctPos.z), _duration);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Board"/> class.
/// </summary>
/// <param name="repository">The repository<see cref="IStatsRepository"/></param>
/// <param name="width">The width<see cref="int"/></param>
/// <param name="height">The height<see cref="int"/></param>
public Board(IStatsRepository repository, int width, int height)
{
_repository = repository;
_pieceBuilder = new PieceBuilder().OnBoard(this);
Dimension = new Size(width, height);
Stats = new Stats();
State = new PausedState();
Matrix = new Block[width, height];
Record = _repository.MaxScore();
}
private void PerformPromotionPieceMove(Board newBoard, Move move)
{
var promotion = move.Promotion;
var pieceHistory = new List <Move>(promotion.PromotingPiece.MoveHistory);
var newPiece = new PieceBuilder(promotion.NewPieceType.Type)
.As(promotion.PromotingPiece.Color)
.At(promotion.NewPosition)
.Create()
.AddRangeToMoveHistory(pieceHistory)
.AddMoveToHistory(move);
newBoard.AddPiece(newPiece);
newBoard[promotion.OldPosition] = null;
}
public void KingCannotMoveIntoCheck()
{
var board = Board.NewEmptyBoard();
var king = new PieceBuilder(PieceType.King)
.As(PieceColor.White)
.At(new Position(File.D, Rank._1))
.Create();
board.AddPiece(king);
board.AddPiece(new PieceBuilder(PieceType.Rook)
.As(PieceColor.Black)
.At(new Position(File.E, Rank._8))
.Create());
var move = MoveBuilder.CreateNormalMove(king,
new Position(File.E, Rank._1), false);
bool putsMeInCheck = board.DoesMovePutKingInCheck(PieceColor.White, move);
Assert.True(putsMeInCheck);
}
private static void BuildDiffPieces(DiffResult diffResult, List<DiffPiece> oldPieces, List<DiffPiece> newPieces, PieceBuilder subPieceBuilder)
{
int aPos = 0;
int bPos = 0;
foreach (var diffBlock in diffResult.DiffBlocks)
{
while (bPos < diffBlock.InsertStartB && aPos < diffBlock.DeleteStartA)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[aPos], ChangeType.Unchanged, aPos + 1));
newPieces.Add(new DiffPiece(diffResult.PiecesNew[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
int i = 0;
for (; i < Math.Min(diffBlock.DeleteCountA, diffBlock.InsertCountB); i++)
{
var oldPiece = new DiffPiece(diffResult.PiecesOld[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1);
var newPiece = new DiffPiece(diffResult.PiecesNew[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1);
if (subPieceBuilder != null)
{
subPieceBuilder(diffResult.PiecesOld[aPos], diffResult.PiecesNew[bPos], oldPiece.SubPieces, newPiece.SubPieces);
newPiece.Type = oldPiece.Type = ChangeType.Modified;
}
oldPieces.Add(oldPiece);
newPieces.Add(newPiece);
aPos++;
bPos++;
}
if (diffBlock.DeleteCountA > diffBlock.InsertCountB)
{
for (; i < diffBlock.DeleteCountA; i++)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1));
newPieces.Add(new DiffPiece());
aPos++;
}
}
else
{
for (; i < diffBlock.InsertCountB; i++)
{
newPieces.Add(new DiffPiece(diffResult.PiecesNew[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1));
oldPieces.Add(new DiffPiece());
bPos++;
}
}
}
while (bPos < diffResult.PiecesNew.Length && aPos < diffResult.PiecesOld.Length)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[aPos], ChangeType.Unchanged, aPos + 1));
newPieces.Add(new DiffPiece(diffResult.PiecesNew[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
}
private static void BuildDiffPieces(DiffResult diffResult, List <DiffPiece> oldPieces, List <DiffPiece> newPieces, PieceBuilder subPieceBuilder)
{
int aPos = 0;
int bPos = 0;
foreach (var diffBlock in diffResult.DiffBlocks)
{
while (bPos < diffBlock.InsertStartB && aPos < diffBlock.DeleteStartA)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[aPos], ChangeType.Unchanged, aPos + 1));
newPieces.Add(new DiffPiece(diffResult.PiecesNew[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
int i = 0;
for (; i < Math.Min(diffBlock.DeleteCountA, diffBlock.InsertCountB); i++)
{
var oldPiece = new DiffPiece(diffResult.PiecesOld[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1);
var newPiece = new DiffPiece(diffResult.PiecesNew[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1);
if (subPieceBuilder != null)
{
subPieceBuilder(diffResult.PiecesOld[aPos], diffResult.PiecesNew[bPos], oldPiece.SubPieces, newPiece.SubPieces);
newPiece.Type = oldPiece.Type = ChangeType.Modified;
}
oldPieces.Add(oldPiece);
newPieces.Add(newPiece);
aPos++;
bPos++;
}
if (diffBlock.DeleteCountA > diffBlock.InsertCountB)
{
for (; i < diffBlock.DeleteCountA; i++)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1));
newPieces.Add(new DiffPiece());
aPos++;
}
}
else
{
for (; i < diffBlock.InsertCountB; i++)
{
newPieces.Add(new DiffPiece(diffResult.PiecesNew[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1));
oldPieces.Add(new DiffPiece());
bPos++;
}
}
}
while (bPos < diffResult.PiecesNew.Length && aPos < diffResult.PiecesOld.Length)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[aPos], ChangeType.Unchanged, aPos + 1));
newPieces.Add(new DiffPiece(diffResult.PiecesNew[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
}
private static ChangeType BuildDiffPieces(DiffResult diffResult, List <DiffPiece> oldPieces, List <DiffPiece> newPieces, PieceBuilder subPieceBuilder, bool ignoreWhiteSpace, bool ignoreCase)
{
int aPos = 0;
int bPos = 0;
ChangeType changeSummary = ChangeType.Unchanged;
foreach (var diffBlock in diffResult.DiffBlocks)
{
while (bPos < diffBlock.InsertStartB && aPos < diffBlock.DeleteStartA)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[aPos], ChangeType.Unchanged, aPos + 1));
newPieces.Add(new DiffPiece(diffResult.PiecesNew[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
int i = 0;
for (; i < Math.Min(diffBlock.DeleteCountA, diffBlock.InsertCountB); i++)
{
var oldPiece = new DiffPiece(diffResult.PiecesOld[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1);
var newPiece = new DiffPiece(diffResult.PiecesNew[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1);
if (subPieceBuilder != null)
{
var subChangeSummary = subPieceBuilder(diffResult.PiecesOld[aPos], diffResult.PiecesNew[bPos], oldPiece.SubPieces, newPiece.SubPieces, ignoreWhiteSpace, ignoreCase);
newPiece.Type = oldPiece.Type = subChangeSummary;
}
oldPieces.Add(oldPiece);
newPieces.Add(newPiece);
aPos++;
bPos++;
}
if (diffBlock.DeleteCountA > diffBlock.InsertCountB)
{
for (; i < diffBlock.DeleteCountA; i++)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1));
newPieces.Add(new DiffPiece());
aPos++;
}
}
else
{
for (; i < diffBlock.InsertCountB; i++)
{
newPieces.Add(new DiffPiece(diffResult.PiecesNew[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1));
oldPieces.Add(new DiffPiece());
bPos++;
}
}
}
while (bPos < diffResult.PiecesNew.Length && aPos < diffResult.PiecesOld.Length)
{
oldPieces.Add(new DiffPiece(diffResult.PiecesOld[aPos], ChangeType.Unchanged, aPos + 1));
newPieces.Add(new DiffPiece(diffResult.PiecesNew[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
// Consider the whole diff as "modified" if we found any change, otherwise we consider it unchanged
if (oldPieces.Any(x => x.Type == ChangeType.Modified || x.Type == ChangeType.Inserted || x.Type == ChangeType.Deleted))
{
changeSummary = ChangeType.Modified;
}
else if (newPieces.Any(x => x.Type == ChangeType.Modified || x.Type == ChangeType.Inserted || x.Type == ChangeType.Deleted))
{
changeSummary = ChangeType.Modified;
}
return(changeSummary);
}
/// <summary>
/// Builds the diff pieces.
/// </summary>
/// <param name="diffResult">Diff result.</param>
/// <param name="firstPieces">First pieces.</param>
/// <param name="secondPieces">Second pieces.</param>
/// <param name="subPieceBuilder">Sub piece builder.</param>
private static void BuildDiffPieces(Result diffResult, List <LineModel> firstPieces, List <LineModel> secondPieces, PieceBuilder subPieceBuilder)
{
int aPos = 0;
int bPos = 0;
foreach (var diffBlock in diffResult.DiffBlocks)
{
while (bPos < diffBlock.InsertStartB && aPos < diffBlock.DeleteStartA)
{
firstPieces.Add(new LineModel(diffResult.PiecesFirst[aPos], ChangeType.Unchanged, aPos + 1));
secondPieces.Add(new LineModel(diffResult.PiecesSecond[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
int i = 0;
for (; i < Math.Min(diffBlock.DeleteCountA, diffBlock.InsertCountB); i++)
{
var oldPiece = new LineModel(diffResult.PiecesFirst[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1);
var newPiece = new LineModel(diffResult.PiecesSecond[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1);
if (subPieceBuilder != null)
{
subPieceBuilder(diffResult.PiecesFirst[aPos], diffResult.PiecesSecond[bPos], oldPiece.SubPieces, newPiece.SubPieces);
newPiece.Type = oldPiece.Type = ChangeType.Modified;
}
firstPieces.Add(oldPiece);
secondPieces.Add(newPiece);
aPos++;
bPos++;
}
if (diffBlock.DeleteCountA > diffBlock.InsertCountB)
{
for (; i < diffBlock.DeleteCountA; i++)
{
firstPieces.Add(new LineModel(diffResult.PiecesFirst[i + diffBlock.DeleteStartA], ChangeType.Deleted, aPos + 1));
secondPieces.Add(new LineModel());
aPos++;
}
}
else
{
for (; i < diffBlock.InsertCountB; i++)
{
secondPieces.Add(new LineModel(diffResult.PiecesSecond[i + diffBlock.InsertStartB], ChangeType.Inserted, bPos + 1));
firstPieces.Add(new LineModel());
bPos++;
}
}
}
while (bPos < diffResult.PiecesSecond.Length && aPos < diffResult.PiecesFirst.Length)
{
firstPieces.Add(new LineModel(diffResult.PiecesFirst[aPos], ChangeType.Unchanged, aPos + 1));
secondPieces.Add(new LineModel(diffResult.PiecesSecond[bPos], ChangeType.Unchanged, bPos + 1));
aPos++;
bPos++;
}
}
