You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
179 lines
6.6 KiB
179 lines
6.6 KiB
/****************************************************************************
|
|
**
|
|
** Definition of GenericTetris, a generic class for implementing Tetris.
|
|
**
|
|
** Author : Eirik Eng
|
|
** Created : 940126
|
|
** Modified by Nicolas Hadacek
|
|
**
|
|
** Copyright (C) 1994 by Eirik Eng. All rights reserved.
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
** The GenericTetris class is an abstract class that can be used to implement
|
|
** the well known game of Tetris. It is totally independent of any hardware
|
|
** platform or user interface mechanism. It has no notion of time, so you
|
|
** have to supply the timer ticks (or heartbeat) of the game. Apart from
|
|
** that this is a complete Tetris implementation.
|
|
**
|
|
** In the following it is assumed that the reader is familiar with the game
|
|
** of Tetris.
|
|
**
|
|
** The class operates on a grid of squares (referred to as the "board" below),
|
|
** where each of the different types of pieces in Tetris covers 4 squares. The
|
|
** width and height of the board can be specified in the constructor (default
|
|
** is 10x22). The coordinate (0,0) is at the TOP LEFT corner. The class
|
|
** assumes that it has total control over the board and uses this to optimize
|
|
** drawing of the board. If you need to update parts of the board
|
|
** (e.g. if you are using a window system), use the updateBoard() function.
|
|
**
|
|
** An implementation of the game must subclass from TetrisBoard and must
|
|
** implement these abstract functions:
|
|
**
|
|
** virtual void drawSquare(int x,int y,int value)
|
|
**
|
|
** This function is called when a square needs to be drawn
|
|
** on the Tetris board. A value of 0 means that the square
|
|
** should be erased. Values of 1 to 7 indicate the different
|
|
** types of pieces. (Thus a minimal implementation can
|
|
** draw 0 in one way and 1-7 in a second way). The x and y
|
|
** values are coordinates on the Tetris board (see above).
|
|
**
|
|
** virtual void gameOver()
|
|
**
|
|
** This function is called when it is impossible to put a new
|
|
** piece at the top of the board.
|
|
**
|
|
** To get a working minimal implementation of Tetris the following functions
|
|
** must be called from the user interface:
|
|
**
|
|
** void startGame()
|
|
**
|
|
** Clears the board and starts a new game.
|
|
**
|
|
** void moveLeft()
|
|
** void moveRight()
|
|
** void rotateLeft()
|
|
** void rotateRight()
|
|
**
|
|
** The standard Tetris controls for moving and rotating the
|
|
** falling pieces.
|
|
**
|
|
** void dropDown();
|
|
**
|
|
** Another Tetris control, drops the falling piece and calls the
|
|
** virtual function pieceDropped(), whose default implementation is
|
|
** to create a new block which appears at the top of the board.
|
|
**
|
|
** void oneLineDown();
|
|
**
|
|
** This is where you supply the timer ticks, or heartbeat, of the
|
|
** game. This function moves the current falling piece one line down
|
|
** on the board, or, if that cannot be done, calls the virtual
|
|
** function pieceDropped() (see dropDown() above). The time between
|
|
** each call to this function directly affects the difficulty of the
|
|
** game. If you want to pause the game, simply block calls to the
|
|
** user control functions above and stop calling this function (you
|
|
** might want to call hideBoard() also).
|
|
**
|
|
** And that's it! There are several other public functions you can call
|
|
** and virtual functions you can overload to modify or extend the game.
|
|
**
|
|
** Do whatever you want with this code (i.e. the files gtetris.h,
|
|
** gtetris.cpp, tpiece.h and tpiece.cpp). It is basically a weekend hack
|
|
** and it would bring joy to my heart if anyone in any way would tqfind
|
|
** it useful.
|
|
**
|
|
** Nostalgia, comments and/or praise can be sent to: Eirik.Eng@troll.no
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef GTETRIS_H
|
|
#define GTETRIS_H
|
|
|
|
#include <tqpoint.h>
|
|
|
|
#include <krandomsequence.h>
|
|
#include <kgrid2d.h>
|
|
|
|
#include <kdemacros.h>
|
|
|
|
class Piece;
|
|
class BlockInfo;
|
|
class Block;
|
|
|
|
struct GTInitData {
|
|
int seed;
|
|
uint initLevel;
|
|
};
|
|
|
|
class KDE_EXPORT GenericTetris
|
|
{
|
|
public:
|
|
GenericTetris(uint width, uint height, bool withPieces, bool graphic);
|
|
virtual ~GenericTetris();
|
|
virtual void copy(const GenericTetris &);
|
|
|
|
void setBlockInfo(BlockInfo *main, BlockInfo *next);
|
|
virtual void start(const GTInitData &);
|
|
|
|
uint moveLeft(int steps = 1) { return moveTo(KGrid2D::Coord(-steps, 0)); }
|
|
uint moveRight(int steps = 1) { return moveTo(KGrid2D::Coord(steps, 0)); }
|
|
bool rotateLeft() { return rotate(true); }
|
|
bool rotateRight() { return rotate(false); }
|
|
virtual void oneLineDown();
|
|
virtual void dropDown();
|
|
|
|
KRandomSequence &randomSequence() { return _random; }
|
|
uint score() const { return _score; }
|
|
uint level() const { return _level; }
|
|
uint nbClearLines() const { return _nbClearLines; }
|
|
uint nbRemoved() const { return _nbRemoved; }
|
|
bool graphic() const { return _graphic; }
|
|
uint firstClearLine() const { return _matrix.height() - _nbClearLines; }
|
|
const KGrid2D::Coord ¤tPos() const { return _currentPos; }
|
|
const Piece *nextPiece() const { return _nextPiece; }
|
|
const Piece *currentPiece() const { return _currentPiece; }
|
|
const KGrid2D::Square<Block *> &matrix() const { return _matrix; }
|
|
|
|
protected:
|
|
Piece *_nextPiece, *_currentPiece;
|
|
|
|
virtual void pieceDropped(uint /*dropHeight*/) {}
|
|
virtual bool newPiece(); // return false if cannot place new piece
|
|
virtual void gluePiece();
|
|
virtual void computeInfos();
|
|
|
|
virtual void updateRemoved(uint newNbRemoved) { _nbRemoved = newNbRemoved;}
|
|
virtual void updateScore(uint newScore) { _score = newScore; }
|
|
virtual void updateLevel(uint newLevel) { _level = newLevel; }
|
|
|
|
void setBlock(const KGrid2D::Coord &, Block *);
|
|
virtual void removeBlock(const KGrid2D::Coord &);
|
|
void moveBlock(const KGrid2D::Coord &src, const KGrid2D::Coord &dest);
|
|
|
|
virtual void updateNextPiece() {}
|
|
virtual void updatePieceConfig() {}
|
|
void bumpCurrentPiece(int dec);
|
|
void partialMoveBlock(const KGrid2D::Coord &, const TQPoint &dec);
|
|
|
|
private:
|
|
TQPoint toPoint(const KGrid2D::Coord &) const;
|
|
uint moveTo(const KGrid2D::Coord &dec);
|
|
bool rotate(bool left);
|
|
void clear();
|
|
bool canPosition(const KGrid2D::Coord &newPos, const Piece *newPiece) const;
|
|
|
|
GenericTetris(const GenericTetris &); // disabled
|
|
|
|
uint _score, _level, _nbRemoved;
|
|
uint _nbClearLines, _initLevel;
|
|
KGrid2D::Coord _currentPos;
|
|
BlockInfo *_main;
|
|
bool _graphic;
|
|
KGrid2D::Square<Block *> _matrix;
|
|
KRandomSequence _random;
|
|
};
|
|
|
|
#endif
|