private void ComputeCurrentPieceDifferences(TetrisState oldState, TetrisState newState, List <TetrisBrickWithPosition> diffList)
{
TetrisPieceWithPosition oldPieceWithPos = oldState?.CurrentPiece;
TetrisPieceWithPosition newPieceWithPos = newState.CurrentPiece;
AddNullsForOldPiece(diffList, oldPieceWithPos);
if (newPieceWithPos == null)
{
return;
}
for (int row = 0; row < newPieceWithPos.Piece.MaxSize; row++)
{
for (int column = 0; column < newPieceWithPos.Piece.MaxSize; column++)
{
int rowRelativeToBoard = row + newPieceWithPos.Position.Row;
int columnRelativeToBoard = column + newPieceWithPos.Position.Column;
TetrisBrick newBrick = newPieceWithPos.Piece[row, column];
if (newBrick != null)
{
diffList.Add(new TetrisBrickWithPosition {
Brick = (TetrisBrick)newBrick.Clone(),
Position = new Coordinates(rowRelativeToBoard, columnRelativeToBoard)
});
}
}
}
}
private TetrisPieceWithPosition PreparePieceCopyForMove(TetrisPieceWithPosition piece, int rowDelta, int columnDelta)
{
PieceCopy.CopyFrom(piece);
PieceCopy.Value.Position.Row += rowDelta;
PieceCopy.Value.Position.Column += columnDelta;
return(PieceCopy.Value);
}
internal int StickPiece()
{
FixedBricksLogic.AddPiece(CurrentPiece);
TetrisFixedBricksState fixedBricks = FixedBricksLogic.DeleteFullRows();
CurrentPiece = null;
return(fixedBricks.DeletedRows);
}
internal bool CanRotatePiece(TetrisPieceWithPosition piece)
{
TetrisPieceWithPosition pieceCopy = PreparePieceCopyForRotate(piece);
if (IsCollision(pieceCopy))
{
return(false);
}
return(true);
}
internal bool CanMovePiece(TetrisPieceWithPosition piece, int rowDelta, int columnDelta)
{
TetrisPieceWithPosition pieceCopy = PreparePieceCopyForMove(piece, rowDelta, columnDelta);
if (IsCollision(pieceCopy))
{
return(false);
}
return(true);
}
private void SetState(TetrisState state)
{
FixedBricksLogic.CopyFixedBricksFromState(state);
if (state.CurrentPiece != null)
{
CurrentPiece = (TetrisPieceWithPosition)state.CurrentPiece.Clone();
}
else
{
CurrentPiece = null;
}
}
int MovePieceAllTheWayDown(TetrisPieceWithPosition piece)
{
int rowDelta = 1;
while (CollisionDetector.CanMovePiece(piece, rowDelta, 0))
{
rowDelta++;
}
rowDelta--;
MovePiece(piece, rowDelta, 0);
return(rowDelta);
}
private void MakeNewPiece()
{
TetrisPieceWithPosition pieceWithPos = MakePieceWithPosition();
if (CollisionDetector.IsCollision(pieceWithPos))
{
CurrentPiece = null;
}
else
{
CurrentPiece = pieceWithPos;
}
}
internal void CopyFrom(TetrisPieceWithPosition original)
{
int maxPieceSize = original.Piece.MaxSize;
if (!Copies.TryGetValue(maxPieceSize, out TetrisPieceWithPosition existingCopy))
{
existingCopy = new TetrisPieceWithPosition {
Piece = new TetrisPiece(maxPieceSize)
};
Copies.Add(maxPieceSize, existingCopy);
}
existingCopy.CopyFrom(original);
Value = existingCopy;
}
internal bool IsCollision(TetrisPieceWithPosition piece)
{
foreach (Coordinates brickCoord in GetBrickCoordinatesRelativeToBoard(piece))
{
bool isLeftWallCollision = brickCoord.Column < 0;
bool isRightWallCollision = brickCoord.Column >= BoardColumnCount;
bool isBottomWallCollision = brickCoord.Row >= BoardRowCount;
bool isFixedBrickCollision = FixedBricks.IsBrick(brickCoord.Row, brickCoord.Column);
if (isLeftWallCollision || isRightWallCollision || isBottomWallCollision || isFixedBrickCollision)
{
return(true);
}
}
return(false);
}
private TetrisPieceWithPosition MakePieceWithPosition()
{
TetrisPieceWithPosition result = new TetrisPieceWithPosition();
if (NextPiece != null)
{
result.Piece = NextPiece;
}
else
{
result.Piece = PieceFactory.MakePiece();
}
NextPiece = PieceFactory.MakePiece();
result.NextPiece = NextPiece;
result.Position = new Coordinates(0, Columns / 2);
return(result);
}
public void AddPiece(TetrisPieceWithPosition pieceWithPos)
{
TetrisPiece piece = pieceWithPos.Piece;
for (int row = 0; row < piece.MaxSize; row++)
{
for (int column = 0; column < piece.MaxSize; column++)
{
TetrisBrick brick = piece[row, column];
if (brick != null)
{
int rowRelativeToBoard = row + pieceWithPos.Position.Row;
int columnRelativeToBoard = column + pieceWithPos.Position.Column;
Bricks[rowRelativeToBoard][columnRelativeToBoard] = (TetrisBrick)brick.Clone();
}
}
}
}
IEnumerable <Coordinates> GetBrickCoordinatesRelativeToBoard(TetrisPieceWithPosition piece)
{
Coordinates coord = new Coordinates(0, 0);
for (int column = 0; column < piece.Piece.MaxSize; column++)
{
for (int row = piece.Piece.MaxSize - 1; row >= 0; row--)
{
bool isPieceBrick = piece.Piece[row, column] != null;
if (isPieceBrick)
{
coord.Row = row + piece.Position.Row;
coord.Column = column + piece.Position.Column;
yield return(coord);
}
}
}
}
private TetrisPieceWithPosition PreparePieceCopyForRotate(TetrisPieceWithPosition piece)
{
PieceCopy.CopyFrom(piece);
PieceCopy.Value.Piece.Rotate90DegreesClockwise();
return(PieceCopy.Value);
}
internal void MovePiece(TetrisPieceWithPosition piece, int rowDelta, int columnDelta)
{
piece.Position.Row += rowDelta;
piece.Position.Column += columnDelta;
}
private static void AddNullsForOldPiece(List <TetrisBrickWithPosition> diffList, TetrisPieceWithPosition oldPieceWithPos)
{
if (oldPieceWithPos == null)
{
return;
}
for (int row = 0; row < oldPieceWithPos.Piece.MaxSize; row++)
{
for (int column = 0; column < oldPieceWithPos.Piece.MaxSize; column++)
{
TetrisBrick oldBrick = oldPieceWithPos.Piece[row, column];
if (oldBrick != null)
{
int rowRelativeToBoard = row + oldPieceWithPos.Position.Row;
int columnRelativeToBoard = column + oldPieceWithPos.Position.Column;
diffList.Add(new TetrisBrickWithPosition {
Brick = null,
Position = new Coordinates(rowRelativeToBoard, columnRelativeToBoard)
});
}
}
}
}
