borgware-2d/games/tetris/playfield.c

781 lines
22 KiB
C

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <inttypes.h>
#include "stdio.h"
#include "playfield.h"
#include "piece.h"
#include "bast.h"
/***************************
* non-interface functions *
***************************/
/* Function: tetris_playfield_hoverStatus;
* Description: determines if piece is either hovering or gliding
* Argument pPl: playfield perform action on
* Return value: TETRIS_PFS_HOVERING or TETRIS_PFS_GLIDING
*/
tetris_playfield_status_t tetris_playfield_hoverStatus(tetris_playfield_t* pPl)
{
// if the piece touches the dump we ensure that the status is "gliding"
if (tetris_playfield_collision(pPl, pPl->nColumn, pPl->nRow + 1))
{
return TETRIS_PFS_GLIDING;
}
// otherwise the status must be "hovering"
else
{
return TETRIS_PFS_HOVERING;
}
}
/****************************
* construction/destruction *
****************************/
/* Function: tetris_playfield_construct
* Description: constructs a playfield with the given dimensions
* Argument nWidth: width of playfield (4 <= n <= 16)
* Argument nHeight: height of playfield (4 <= n <= 124)
* Return value: pointer to a newly created playfield
*/
tetris_playfield_t *tetris_playfield_construct(int8_t nWidth,
int8_t nHeight)
{
assert((nWidth >= 4) && (nWidth <= 16));
assert((nHeight >= 4) && (nHeight <= 124));
tetris_playfield_t *pPlayfield =
(tetris_playfield_t*) malloc(sizeof(tetris_playfield_t));
if (pPlayfield != NULL)
{
// allocating mem for dump array
pPlayfield->dump = (uint16_t*) calloc(nHeight, sizeof(uint16_t));
if (pPlayfield->dump != NULL)
{
// setting desired attributes
pPlayfield->nWidth = nWidth;
pPlayfield->nHeight = nHeight;
tetris_playfield_reset(pPlayfield);
return pPlayfield;
}
else
{
free(pPlayfield);
pPlayfield = NULL;
}
}
return NULL;
}
/* Function: tetris_playfield_destruct
* Description: destructs a playfield
* Argument pPl: pointer to the playfield to be destructed
* Return value: void
*/
void tetris_playfield_destruct(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
// if memory for the dump array has been allocated, free it
if (pPl->dump != NULL)
{
free(pPl->dump);
}
free(pPl);
}
/*******************************
* playfield related functions *
*******************************/
/* Function: tetris_playfield_reset
* Description: resets playfield to begin a new game
* Argument pPl: playfield to perform action on
* Return value: void
*/
void tetris_playfield_reset(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
pPl->pPiece = NULL;
pPl->nColumn = 0;
pPl->nRow = 0;
pPl->nRowMask = 0;
// clear dump if it has been allocated in memory
if (pPl->dump != NULL)
{
memset(pPl->dump, 0, pPl->nHeight);
}
pPl->status = TETRIS_PFS_READY;
}
int8_t tetris_playfield_getPieceStartPos(tetris_piece_t *pPiece)
{
// set vertical start position (first piece row with matter at pos. 1)
uint16_t nPieceMap = tetris_piece_getBitmap(pPiece);
uint16_t nElementMask = 0xF000;
int8_t nRow = -3;
while ((nPieceMap & nElementMask) == 0)
{
++nRow;
nElementMask >>= 4;
}
if (nRow < 0)
{
++nRow;
}
return nRow;
}
/* Function: tetris_playfield_insertPiece
* Description: inserts a new piece
* Argument pPl: playfield to perform action on
* Argument pPiece: piece to be inserted
* Argument ppOldPiece: [out] indirect pointer to former piece for deallocation
* Return value: void
*/
void tetris_playfield_insertPiece(tetris_playfield_t *pPl,
tetris_piece_t *pPiece,
tetris_piece_t** ppOldPiece)
{
assert((pPl != NULL) && (pPiece != NULL) && (ppOldPiece != NULL));
// a piece can only be inserted in state TETRIS_PFS_READY
assert(pPl->status == TETRIS_PFS_READY);
// row mask is now meaningless
pPl->nRowMask = 0;
// replace old piece
*ppOldPiece = pPl->pPiece;
pPl->pPiece = pPiece;
// set horizontal start position (in the middle of the top line)
pPl->nColumn = (pPl->nWidth - 2) / 2;
// set vertical start position (first piece row with matter at pos. 1)
pPl->nRow = tetris_playfield_getPieceStartPos(pPl->pPiece);
// did we already collide with something?
if (tetris_playfield_collision(pPl, pPl->nColumn, pPl->nRow) == 1)
{
// game over man, game over!!
pPl->status = TETRIS_PFS_GAMEOVER;
}
else
{
// bring it on!
pPl->status = tetris_playfield_hoverStatus(pPl);
}
}
/* Function: tetris_playfield_collision
* Description: detects if piece collides with s.th. at a given position
* Argument pPl: playfield to perform action on
* Argument nColumn: column where the piece should be moved
* Argument nRow: row where the piece should be moved
* Return value: 1 for collision, 0 otherwise
*/
uint8_t tetris_playfield_collision(tetris_playfield_t *pPl,
int8_t nColumn,
int8_t nRow)
{
assert(pPl != NULL);
// only allow coordinates which are within sane ranges
assert((nColumn >= -4) && (nColumn < pPl->nWidth));
assert((nRow >= -4) && (nRow < pPl->nHeight));
// The rows of a piece get compared with the background one by one
// until either a collision occures or all rows are compared. Both the
// piece row and the part of the playfield it covers are represented in
// 4 bits which were singled out from their corresponding uint16_t
// values and are aligned to LSB. In case where a piece overlaps with
// either the left or the right border we "enhance" the playfield part
// via bit shifting and set all bits representing the border to 1.
//
// NOTE: LSB represents the left most position.
uint16_t nPieceMap = tetris_piece_getBitmap(pPl->pPiece);
uint16_t nPlayfieldPart;
uint16_t nPieceRowMap;
// negative nRow values indicate that the piece hasn't fully entered the
// playfield yet which requires special treatment if the piece overlaps
// with either the left or the right border
if (nRow < 0)
{
uint16_t nBorderMask = 0x0000;
// piece overlaps with left border
if (nColumn < 0)
{
nBorderMask = 0x1111 << (-nColumn - 1);
}
// piece overlaps with right border
else if ((nColumn + 3) >= pPl->nWidth)
{
nBorderMask = 0x8888 >> ((nColumn + 3) - pPl->nWidth);
}
// return if piece collides with border
if ((nPieceMap & nBorderMask) != 0)
{
return 1;
}
}
// here we check the part which has already entered the playfield
for (int8_t y = (nRow < 0) ? -nRow : 0; y < 4; ++y)
{
// current piece row overlaps with lower border
if ((y + nRow) >= pPl->nHeight)
{
// all 4 bits represent the lower border
nPlayfieldPart = 0x000F;
}
// piece overlaps with left border
else if (nColumn < 0)
{
// clear all bits we are not interested in
nPlayfieldPart = (pPl->dump[y + nRow] & (0x000F >> -nColumn));
// add zeros to the left (the bits "behind" the left border)
nPlayfieldPart <<= -nColumn;
// set bits beyond left border to 1
nPlayfieldPart |= 0x000F >> (4 + nColumn);
}
// piece overlaps with right border
else if ((nColumn + 3) >= pPl->nWidth)
{
// align the bits we are interested in to LSB
// (thereby clearing the rest)
nPlayfieldPart = pPl->dump[y + nRow] >> nColumn;
// set bits beyond right border to 1
nPlayfieldPart |= 0xFFF8 >> (nColumn + 3 - pPl->nWidth);
}
// current row neither overlaps with left, right nor lower border
else
{
// clear all bits we are not interested in and align the
// remaing row to LSB
nPlayfieldPart =
(pPl->dump[y + nRow] & (0x000F << nColumn)) >> nColumn;
}
// clear all bits of the piece we are not interested in and
// align the remaing row to LSB
nPieceRowMap = (nPieceMap & (0x000F << (y << 2))) >> (y << 2);
// finally check for a collision
if ((nPlayfieldPart & nPieceRowMap) != 0)
{
return 1;
}
}
// if we reach here, no collision was detected
return 0;
}
/* Function: tetris_playfield_advancePiece
* Description: lowers piece by one row or finally docks it
* Argument pPl: playfield to perform action on
* Return value: void
*/
void tetris_playfield_advancePiece(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
// a piece can only be lowered if it is hovering or gliding
assert ((pPl->status == TETRIS_PFS_HOVERING) ||
(pPl->status == TETRIS_PFS_GLIDING));
if (tetris_playfield_collision(pPl, pPl->nColumn, pPl->nRow + 1))
{
uint16_t nPiece = tetris_piece_getBitmap(pPl->pPiece);
// Is the playfield filled up?
if ((pPl->nRow < 0) && (nPiece & (0x0FFF >> ((3 + pPl->nRow) << 2))) != 0)
{
pPl->status = TETRIS_PFS_GAMEOVER;
}
else
{
// determine valid start point for dump index
int8_t nStartRow = ((pPl->nRow + 3) < pPl->nHeight) ?
(pPl->nRow + 3) : pPl->nHeight - 1;
for (int8_t i = nStartRow; i >= pPl->nRow; --i)
{
int8_t y = i - pPl->nRow;
// clear all bits of the piece we are not interested in and
// align the rest to LSB
uint16_t nPieceMap = (nPiece & (0x000F << (y << 2))) >> (y << 2);
// shift the remaining content to the current column
if (pPl->nColumn >= 0)
{
nPieceMap <<= pPl->nColumn;
}
else
{
nPieceMap >>= -pPl->nColumn;
}
// embed piece in playfield
pPl->dump[i] |= nPieceMap;
}
// the piece has finally been docked
pPl->status = TETRIS_PFS_DOCKED;
}
}
else
{
// since there is no collision the piece may continue its travel
// to the ground...
pPl->nRow++;
// are we gliding?
pPl->status = tetris_playfield_hoverStatus(pPl);
}
}
/* Function: tetris_playfield_movePiece
* Description: moves piece to the given direction
* Argument pPl: playfield to perform action on
* Argument direction: direction (see tetris_playfield_direction_t)
* Return value: 1 if piece could be moved, 0 otherwise
*/
uint8_t tetris_playfield_movePiece(tetris_playfield_t *pPl,
tetris_playfield_direction_t direction)
{
assert(pPl != NULL);
// a piece can only be moved if it is still hovering or gliding
assert((pPl->status == TETRIS_PFS_HOVERING) ||
(pPl->status == TETRIS_PFS_GLIDING));
int8_t nOffset = (direction == TETRIS_PFD_LEFT) ? -1 : 1;
if (tetris_playfield_collision(pPl, pPl->nColumn + nOffset, pPl->nRow) == 0)
{
pPl->nColumn += nOffset;
// are we gliding?
pPl->status = tetris_playfield_hoverStatus(pPl);
return 1;
}
return 0;
}
/* Function: tetris_playfield_rotatePiece
* Description: rotates piece to the given direction
* Argument pPl: playfield to perform action on
* Argument r: type of rotation (see tetris_piece_rotation_t)
* Return value: 1 if piece could be rotated, 0 otherwise
*/
uint8_t tetris_playfield_rotatePiece(tetris_playfield_t *pPl,
tetris_piece_rotation_t rotation)
{
assert(pPl != NULL);
// a piece can only be rotation if it is still hovering or gliding
assert((pPl->status == TETRIS_PFS_HOVERING) ||
(pPl->status == TETRIS_PFS_GLIDING));
tetris_piece_rotate(pPl->pPiece, rotation);
// does the rotated piece cause a collision?
if (tetris_playfield_collision(pPl, pPl->nColumn, pPl->nRow) != 0)
{
// in that case we revert the rotation
if (rotation == TETRIS_PC_ROT_CW)
{
tetris_piece_rotate(pPl->pPiece, TETRIS_PC_ROT_CCW);
}
else
{
tetris_piece_rotate(pPl->pPiece, TETRIS_PC_ROT_CW);
}
return 0;
}
// are we gliding?
pPl->status = tetris_playfield_hoverStatus(pPl);
return 1;
}
/* Function: tetris_playfield_removeCompletedLines
* Description: removes completed lines (if any) and lowers the dump
* Argument pPl: playfield to perform action on
* Return value: void
*/
void tetris_playfield_removeCompleteLines(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
// rows can only be removed if we are in state TETRIS_PFS_DOCKED
assert(pPl->status == TETRIS_PFS_DOCKED);
// bit mask of a full row
uint16_t nFullRow = 0xFFFF >> (16 - pPl->nWidth);
// bit mask (only 4 bits) that tells us if the n-th row after the
// current nRow is complete (n-th bit set to 1, LSB represents nRow itself)
uint8_t nRowMask = 0;
// determine sane start and stop values for the dump' index
int8_t nStartRow =
((pPl->nRow + 3) >= pPl->nHeight) ? pPl->nHeight - 1 : pPl->nRow + 3;
int8_t nStopRow = (pPl->nRow < 0) ? 0 : pPl->nRow;
// dump index variables
// for incomplete rows, both variables will be decremented
// for complete rows, only i gets decremented
int8_t nLowestRow = nStartRow;
// this loop only considers rows which are affected by the piece
for (int8_t i = nStartRow; i >= nStopRow; --i)
{
// is current row a full row?
if ((nFullRow & pPl->dump[i]) == nFullRow)
{
// set corresponding bit for the row mask
// nRowMask |= 0x08 >> (nStartRow - i);
nRowMask |= 0x01 << (i - pPl->nRow);
}
else
{
// if nLowestRow and i differ, the dump has to be shifted
if (i < nLowestRow)
{
pPl->dump[nLowestRow] = pPl->dump[i];
}
--nLowestRow;
}
}
// if rows have been removed, this loop shifts the rest of the dump
uint8_t nComplete = nLowestRow - nStopRow + 1;
if (nComplete > 0)
{
for (int8_t i = nStopRow - 1; nLowestRow >= 0; --i)
{
// is the row we are copying from below the upper border?
if (i >= 0)
{
// just copy from that row
pPl->dump[nLowestRow] = pPl->dump[i];
}
else
{
// rows above the upper border are always empty
pPl->dump[nLowestRow] = 0;
}
--nLowestRow;
}
}
// ready to get the next piece
pPl->status = TETRIS_PFS_READY;
pPl->nRowMask = nRowMask;
}
/*****************
* get functions *
*****************/
/* Function: tetris_playfield_getWidth
* Description: returns the width of the playfield
* Argument pPl: the playfield we want information from
* Return value: width of the playfield
*/
int8_t tetris_playfield_getWidth(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
return pPl->nWidth;
}
/* Function: tetris_playfield_getHeight
* Description: returns the height of the ayfield we want information from
* Return value: height of the playfield
*/
int8_t tetris_playfield_getHeight(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
return pPl->nHeight;
}
/* Function: tetris_playfield_getPiece
* Description: returns the currently falling piece
* Argument pPl: the playfield we want information from
* Return value: pointer to the currently falling piece
*/
tetris_piece_t *tetris_playfield_getPiece(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
return pPl->pPiece;
}
/* Function: tetris_playfield_getColumn
* Description: returns the column of the currently falling piece
* Argument pPl: the playfield we want information from
* Return value: column of the currently falling piece
*/
int8_t tetris_playfield_getColumn(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
return pPl->nColumn;
}
/* Function: tetris_playfield_getRow
* Description: returns the row of the currently falling piece
* Argument pPl: the playfield we want information from
* Return value: row of the currently falling piece
*/
int8_t tetris_playfield_getRow(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
return pPl->nRow;
}
/* Function: tetris_playfield_getRowMask
* Description: returns the row mask relative to nRow
* Argument pPl: the playfield we want information from
* Return value: the first 4 bits indicate which lines (relative to nRow)
* have been removed if we are in status TETRIS_PFS_READY
* LSB is the highest line
*/
uint8_t tetris_playfield_getRowMask(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
return pPl->nRowMask;
}
/* Function: tetris_playfield_getStatus
* Description: returns the status of the playfield
* Argument pPl: the playfield we want information from
* Return value: status of the playfield (see tetris_playfield_status_t)
*/
tetris_playfield_status_t tetris_playfield_getStatus(tetris_playfield_t *pPl)
{
assert(pPl != NULL);
return pPl->status;
}
/* Function: tetris_playfield_getDumpRow
* Description: returns the given row of the dump (as bitmap)
* Argument pPl: the playfield we want information from
* Argument nRow: the number of the row (0 <= nRow < height of playfield)
* Return value: bitmap of the requested row (LSB is leftmost column)
*/
uint16_t tetris_playfield_getDumpRow(tetris_playfield_t *pPl,
int8_t nRow)
{
assert(pPl != NULL);
assert((0 <= nRow) && (nRow < pPl->nHeight));
return pPl->dump[nRow];
}
/* Function: tetris_playfield_predictDeepestRow
* Description: returns the deepest possible row of a given piece
* Argument pPl: the playfield on which we want to test a piece
* Argument pPiece: the piece which should be tested
* Argument nColumn: the column where the piece should be dropped
* Return value: the row of the piece (playfield compliant coordinates)
*/
int8_t tetris_playfield_predictDeepestRow(tetris_playfield_t *pPl,
tetris_piece_t *pPiece,
int8_t nColumn)
{
int8_t nRow = tetris_playfield_getPieceStartPos(pPiece);
tetris_piece_t *pActualPiece = pPl->pPiece;
pPl->pPiece = pPiece;
// is it actually possible to use this piece?
if (tetris_playfield_collision(pPl, (pPl->nWidth - 2) / 2, nRow) ||
(tetris_playfield_collision(pPl, nColumn, nRow)))
{
return -4;
}
// determine deepest row
while ((nRow < pPl->nHeight) &&
(!tetris_playfield_collision(pPl, nColumn, nRow + 1)))
{
++nRow;
}
// restore real piece
pPl->pPiece = pActualPiece;
return nRow;
}
/* Function: tetris_playfield_predictCompleteLines
* Description: predicts the number of complete lines for a piece at
* a given column
* Argument pPl: the playfield on which we want to test a piece
* Argument pPiece: the piece which should be tested
* Argument nColumn: the column where the piece should be dropped
* Return value: amount of complete lines
*/
int8_t tetris_playfield_predictCompleteLines(tetris_playfield_t *pPl,
tetris_piece_t *pPiece,
int8_t nColumn)
{
int8_t nCompleteRows = 0;
// bit mask of a full row
uint16_t nFullRow = 0xFFFF >> (16 - pPl->nWidth);
int8_t nRow = tetris_playfield_predictDeepestRow(pPl, pPiece, nColumn);
if (nRow > -4)
{
// determine sane start and stop values for the dump's index
int8_t nStartRow =
((nRow + 3) >= pPl->nHeight) ? pPl->nHeight - 1 : nRow + 3;
int8_t nStopRow = (nRow < 0) ? 0 : nRow;
uint16_t nPiece = tetris_piece_getBitmap(pPiece);
for (int8_t i = nStartRow; i >= nStopRow; --i)
{
int8_t y = i - nRow;
// clear all bits of the piece we are not interested in and
// align the rest to LSB
uint16_t nPieceMap = (nPiece & (0x000F << (y << 2))) >> (y << 2);
// shift the remaining content to the current column
if (nColumn >= 0)
{
nPieceMap <<= nColumn;
}
else
{
nPieceMap >>= -nColumn;
}
// embed piece in dump map
uint16_t nDumpMap = pPl->dump[i] | nPieceMap;
// is current row a full row?
if ((nFullRow & nDumpMap) == nFullRow)
{
++nCompleteRows;
}
}
}
return nCompleteRows;
}
/* Function: tetris_playfield_predictBottomRow
* Description: predicts the appearance of the bottom row of the
* playfield (for a piece at a given column) and
* initializes an iterator structure
* Argument pIt: [out] a pointer to an iterator which should be initialized
* Argument pPl: the playfield on which we want to test a piece
* Argument pPiece: the piece which should be tested
* Argument nColumn: the column where the piece should be dropped
* Return value: appearance of the predicted dump row at the bottom
*/
uint16_t* tetris_playfield_predictBottomRow(tetris_playfield_iterator_t *pIt,
tetris_playfield_t *pPl,
tetris_piece_t *pPiece,
int8_t nColumn)
{
pIt->pPlayfield = pPl;
pIt->pPiece = pPiece;
pIt->nColumn = nColumn;
pIt->nDeepestPieceRow =
tetris_playfield_predictDeepestRow(pPl, pPiece, nColumn);
pIt->nFullRow = 0xFFFF >> (16 - pPl->nWidth);
pIt->nCurrentRow = pPl->nHeight - 1;
pIt->nRowBuffer = 0;
return tetris_playfield_predictNextRow(pIt);
}
/* Function: tetris_playfield_predictNextRow
* Description: predicts the appearance of the next row of the playfield
* (for a given iterator)
* Argument pIt: a pointer to a dump iterator
* Return value: appearance of the next predicted dump row
*/
uint16_t* tetris_playfield_predictNextRow(tetris_playfield_iterator_t *pIt)
{
uint16_t nPieceMap = 0;
if ((pIt->nDeepestPieceRow > -4) && (pIt->nCurrentRow >= 0))
{
// determine sane start and stop values for the piece's indices
int8_t nStartRow =
((pIt->nDeepestPieceRow + 3) < pIt->pPlayfield->nHeight) ?
(pIt->nDeepestPieceRow + 3) : pIt->pPlayfield->nHeight - 1;
uint16_t nPiece = tetris_piece_getBitmap(pIt->pPiece);
if ((pIt->nCurrentRow <= nStartRow) &&
(pIt->nCurrentRow >= pIt->nDeepestPieceRow))
{
int8_t y = pIt->nCurrentRow - pIt->nDeepestPieceRow;
// clear all bits of the piece we are not interested in and
// align the rest to LSB
nPieceMap = (nPiece & (0x000F << (y << 2))) >> (y << 2);
// shift the remaining content to the current column
if (pIt->nColumn >= 0)
{
nPieceMap <<= pIt->nColumn;
}
else
{
nPieceMap >>= -pIt->nColumn;
}
}
pIt->nRowBuffer = pIt->pPlayfield->dump[pIt->nCurrentRow--] | nPieceMap;
// don't return full (and therefore removed) rows
if (pIt->nRowBuffer == pIt->nFullRow)
{
// recursively determine next row
return tetris_playfield_predictNextRow(pIt);
}
else
{
return &pIt->nRowBuffer;
}
}
else
{
return NULL;
}
}