Source Code (Use browser search to find items of interest.)
Class Index
ksirtet'Board (./kdegames/ksirtet/board.h:23)
class Board : public QFrame, public GenericTetris
{
Q_OBJECT
public:
Board(uint blockWidth, uint blockHeight,
uint width, uint height, bool graphical, GiftPool *,
QWidget *parent, const char *name=0);
virtual ~Board();
void setType(bool computer);
virtual void init(int seed);
virtual void start();
void pause();
void unpause();
void stop();
QSize sizeHint() const;
QSizePolicy sizePolicy() const;
virtual uint gift() = 0;
bool isGameOver() const { return _end; }
virtual bool needRemoving() = 0;
virtual void remove() = 0;
GiftPool *giftPool() const { return _giftPool; }
BlockInfo *next() const { return _next; }
uint blockWidth() const;
uint blockHeight() const;
int firstColumnBlock(uint column) const;
void AIConfigChanged();
void enableAnimations(bool enabled) { _animations = enabled; }
public slots:
void pMoveLeft();
void pMoveRight();
void pDropDown();
void pOneLineDown();
void pRotateLeft();
void pRotateRight();
private slots:
void timeout();
signals:
void showNextPieceSignal(bool hide);
void showPieceConfigSignal(bool hide);
void updateRemovedSignal(int nbRemoved);
void updateScoreSignal(int score);
void updateLevelSignal(int level);
protected:
// standard methods
void newPiece();
void gameOver();
void pieceDropped(uint dropHeight);
virtual bool beforeGlue(bool bump, bool first);
virtual void gluePiece();
virtual bool afterGlue(bool /*doAll*/) { return FALSE; }
virtual bool beforeRemove(bool /*first*/) { return FALSE; }
enum AfterRemoveResult { Done, NeedAfterRemove, NeedRemoving };
virtual AfterRemoveResult afterRemove(bool /*doAll*/, bool /*first*/)
{ return Done; }
virtual bool afterGift() { return FALSE; }
virtual bool putGift(uint) = 0;
void updateRemoved(uint addRemoved);
void updateScore(uint newScore);
void updateLevel(uint newLlevel);
uint loop;
KRandomSequence randomGarbage;
Info info;
bool _animations;
private:
void checkGift();
void _afterGift();
void _beforeGlue(bool first);
void _afterGlue();
void _beforeRemove(bool first);
void _afterRemove(bool first);
void startTimer();
void showNextPiece(bool show) { emit showNextPieceSignal(!show); }
void showPieceConfig(bool show) { emit showPieceConfigSignal(!show); }
void showBoard(bool show);
void showCanvas(QCanvas *c, bool show);
enum BoardState { Normal, DropDown, BeforeGlue, AfterGlue, BeforeRemove,
AfterRemove, AfterGift };
BoardState state;
QTimer timer;
uint _dropHeight;
bool _end;
GiftPool *_giftPool;
AI *aiEngine;
SequenceArray *sequences;
BlockInfo *main, *_next;
QCanvasView *view;
};
ksirtet'Board::Board() (./kdegames/ksirtet/board.cpp:8)
Board::Board(uint blockWidth, uint blockHeight,
uint width, uint height, bool graphic, GiftPool *gp,
QWidget *parent, const char *name)
: QFrame(parent, name), GenericTetris(width, height, graphic),
state(Normal), timer(this), _giftPool(gp), aiEngine(0),
sequences(0), main(0), _next(0), view(0)
{
if (graphic) {
sequences = new SequenceArray(blockWidth, blockHeight);
main = new BlockInfo(matrix().width(), matrix().height(), *sequences);
const GPieceInfo *info = Piece::info();
_next = new BlockInfo(info->maxWidth() + 2,
info->maxHeight() + 2, *sequences);
connect(&timer, SIGNAL(timeout()), SLOT(timeout()));
setFrameStyle( QFrame::Panel | QFrame::Sunken );
setBlockInfo(main, _next);
view = new QCanvasView(main, this);
view->setGeometry(frameWidth(), frameWidth(),
main->width()+5, main->height()+5);
}
}
ksirtet'Board::~Board() (./kdegames/ksirtet/board.cpp:30)
Board::~Board()
{
delete aiEngine;
delete _next;
delete main;
delete sequences;
}
ksirtet'Board::sizeHint() (./kdegames/ksirtet/board.cpp:38)
QSize Board::sizeHint() const
{
if ( !graphic() ) return QSize();
int fw = 2* frameWidth();
return QSize(fw + view->width(), fw + view->height());
}
ksirtet'Board::sizePolicy() (./kdegames/ksirtet/board.cpp:45)
QSizePolicy Board::sizePolicy() const
{
return QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
}
ksirtet'Board::setType() (./kdegames/ksirtet/board.cpp:50)
void Board::setType(bool _ai)
{
ASSERT( graphic() );
if (_ai) {
if ( aiEngine==0 ) {
aiEngine = createAI();
connect(aiEngine, SIGNAL(rotateLeft()), SLOT(pRotateLeft()));
connect(aiEngine, SIGNAL(rotateRight()), SLOT(pRotateRight()));
connect(aiEngine, SIGNAL(moveLeft()), SLOT(pMoveLeft()));
connect(aiEngine, SIGNAL(moveRight()), SLOT(pMoveRight()));
connect(aiEngine, SIGNAL(dropDown()), SLOT(pDropDown()));
}
} else {
delete aiEngine;
aiEngine = 0;
}
}
ksirtet'Board::init() (./kdegames/ksirtet/board.cpp:68)
void Board::init(int _seed)
{
GenericTetris::init(_seed);
randomGarbage.setSeed(_seed);
}
ksirtet'Board::start() (./kdegames/ksirtet/board.cpp:74)
void Board::start()
{
ASSERT( graphic() );
_end = FALSE;
state = Normal;
GenericTetris::start(); // NB: the timer is started by updateLevel !
}
ksirtet'Board::gameOver() (./kdegames/ksirtet/board.cpp:82)
void Board::gameOver()
{
_end = TRUE;
}
ksirtet'Board::stop() (./kdegames/ksirtet/board.cpp:87)
void Board::stop()
{
ASSERT( graphic() );
timer.stop();
if (aiEngine) aiEngine->stop();
}
ksirtet'Board::pause() (./kdegames/ksirtet/board.cpp:94)
void Board::pause()
{
ASSERT( graphic() );
stop();
showBoard(FALSE);
}
ksirtet'Board::showCanvas() (./kdegames/ksirtet/board.cpp:101)
void Board::showCanvas(QCanvas *c, bool show)
{
QCanvasItemList l = c->allItems();
QCanvasItemList::Iterator it;
for (it=l.begin(); it!=l.end(); ++it) {
if (show) (*it)->show();
else (*it)->hide();
}
c->update();
}
ksirtet'Board::showBoard() (./kdegames/ksirtet/board.cpp:112)
void Board::showBoard(bool show)
{
showCanvas(main, show);
showCanvas(_next, show);
}
ksirtet'Board::unpause() (./kdegames/ksirtet/board.cpp:118)
void Board::unpause()
{
ASSERT( graphic() );
showBoard(TRUE);
startTimer();
if (aiEngine) aiEngine->start(); // eventually restart thinking
}
ksirtet'Board::updateRemoved() (./kdegames/ksirtet/board.cpp:126)
void Board::updateRemoved(uint newNbRemoved)
{
GenericTetris::updateRemoved(newNbRemoved);
emit updateRemovedSignal(newNbRemoved);
}
ksirtet'Board::updateScore() (./kdegames/ksirtet/board.cpp:132)
void Board::updateScore(uint newScore)
{
GenericTetris::updateScore(newScore);
emit updateScoreSignal(newScore);
}
ksirtet'Board::updateLevel() (./kdegames/ksirtet/board.cpp:138)
void Board::updateLevel(uint newLevel)
{
GenericTetris::updateLevel(newLevel);
emit updateLevelSignal(newLevel);
if ( graphic() ) startTimer();
}
ksirtet'Board::blockWidth() (./kdegames/ksirtet/board.cpp:145)
uint Board::blockWidth() const
{
return sequences->blockWidth();
}
ksirtet'Board::blockHeight() (./kdegames/ksirtet/board.cpp:150)
uint Board::blockHeight() const
{
return sequences->blockHeight();
}
ksirtet'Board::firstColumnBlock() (./kdegames/ksirtet/board.cpp:155)
int Board::firstColumnBlock(uint col) const
{
for (int j=firstClearLine()-1; j>=0; j--)
if ( matrix()(col, j)!=0 ) return j;
return -1;
}
ksirtet'Board::AIConfigChanged() (./kdegames/ksirtet/board.cpp:162)
void Board::AIConfigChanged()
{
if (aiEngine) aiEngine->configChanged();
}
/*****************************************************************************/
ksirtet'Board::pMoveLeft() (./kdegames/ksirtet/board.cpp:168)
void Board::pMoveLeft()
{
if ( state==Normal ) {
moveLeft();
main->update();
}
}
ksirtet'Board::pMoveRight() (./kdegames/ksirtet/board.cpp:176)
void Board::pMoveRight()
{
if ( state==Normal ) {
moveRight();
main->update();
}
}
ksirtet'Board::pOneLineDown() (./kdegames/ksirtet/board.cpp:184)
void Board::pOneLineDown()
{
if ( state==Normal ) {
oneLineDown();
main->update();
}
}
ksirtet'Board::pRotateLeft() (./kdegames/ksirtet/board.cpp:192)
void Board::pRotateLeft()
{
if ( state==Normal ) {
rotateLeft();
main->update();
}
}
ksirtet'Board::pRotateRight() (./kdegames/ksirtet/board.cpp:200)
void Board::pRotateRight()
{
if ( state==Normal ) {
rotateRight();
main->update();
}
}
ksirtet'Board::pDropDown() (./kdegames/ksirtet/board.cpp:208)
void Board::pDropDown()
{
if ( state!=Normal ) return;
if ( !graphic() ) dropDown();
else {
_dropHeight = 0;
oneLineDown();
if ( state!=Normal ) return;
state = DropDown;
startTimer();
}
}
ksirtet'Board::pieceDropped() (./kdegames/ksirtet/board.cpp:221)
void Board::pieceDropped(uint dropHeight)
{
if ( state==DropDown ) state = Normal;
else _dropHeight = dropHeight;
_beforeGlue(TRUE);
}
ksirtet'Board::_beforeGlue() (./kdegames/ksirtet/board.cpp:228)
void Board::_beforeGlue(bool first)
{
if ( graphic() ) {
state = (beforeGlue(_dropHeight>=1, first) ? BeforeGlue : Normal);
if ( state==BeforeGlue ) {
startTimer();
return;
}
}
gluePiece();
}
ksirtet'Board::gluePiece() (./kdegames/ksirtet/board.cpp:240)
void Board::gluePiece()
{
GenericTetris::gluePiece();
_afterGlue();
}
ksirtet'Board::_afterGlue() (./kdegames/ksirtet/board.cpp:246)
void Board::_afterGlue()
{
bool b = afterGlue( !graphic() );
if ( graphic() ) {
state = (b ? AfterGlue : Normal);
if ( state==AfterGlue ) {
computeClearLines();
startTimer();
return;
}
}
computeClearLines();
updateScore(score() + _dropHeight);
if ( needRemoving() ) {
_beforeRemove(TRUE);
return;
}
checkGift();
}
ksirtet'Board::_beforeRemove() (./kdegames/ksirtet/board.cpp:266)
void Board::_beforeRemove(bool first)
{
if ( graphic() ) {
state = ( beforeRemove(first) ? BeforeRemove : Normal );
if ( state==BeforeRemove ) {
startTimer();
return;
}
}
remove();
_afterRemove(TRUE);
}
ksirtet'Board::_afterRemove() (./kdegames/ksirtet/board.cpp:279)
void Board::_afterRemove(bool first)
{
AfterRemoveResult r = afterRemove(!graphic(), first);
switch (r) {
case Done: state = Normal; checkGift(); return;
case NeedAfterRemove: state = AfterRemove; startTimer(); return;
case NeedRemoving: _beforeRemove(TRUE); return;
}
}
ksirtet'Board::checkGift() (./kdegames/ksirtet/board.cpp:289)
void Board::checkGift()
{
if ( graphic() ) {
if ( _giftPool->pending() ) {
if ( putGift(_giftPool->take()) ) _afterGift();
else gameOver();
return;
}
}
newPiece();
}
ksirtet'Board::_afterGift() (./kdegames/ksirtet/board.cpp:301)
void Board::_afterGift()
{
ASSERT( graphic() );
if ( afterGift() ) {
state = AfterGift;
startTimer();
} else {
state = Normal;
checkGift();
}
}
ksirtet'Board::newPiece() (./kdegames/ksirtet/board.cpp:313)
void Board::newPiece()
{
ASSERT( state==Normal );
GenericTetris::newPiece();
if ( graphic() ) {
main->update();
_next->update();
startTimer();
if (aiEngine) aiEngine->launch(this);
// else : a human player can think by himself ...
}
}
ksirtet'Board::timeout() (./kdegames/ksirtet/board.cpp:326)
void Board::timeout()
{
ASSERT( graphic() );
switch (state) {
case DropDown: _dropHeight++;
case Normal: oneLineDown(); break;
case BeforeGlue: _beforeGlue(FALSE); break;
case AfterGlue: _afterGlue(); break;
case BeforeRemove: _beforeRemove(FALSE); break;
case AfterRemove: _afterRemove(FALSE); break;
case AfterGift: _afterGift(); break;
}
main->update();
}
ksirtet'Board::startTimer() (./kdegames/ksirtet/board.cpp:341)
void Board::startTimer()
{
ASSERT( graphic() );
switch (state) {
case Normal: timer.start(info.baseTime / (1 + level())); break;
case DropDown: timer.start(info.dropDownTime); break;
case BeforeGlue: timer.start(info.beforeGlueTime, TRUE); break;
case AfterGlue: timer.start(info.afterGlueTime, TRUE); break;
case BeforeRemove: timer.start(info.beforeRemoveTime, TRUE); break;
case AfterRemove: timer.start(info.afterRemoveTime, TRUE); break;
case AfterGift: timer.start(info.afterGiftTime, TRUE); break;
}
}
//-----------------------------------------------------------------------------
ksirtet'Board::beforeGlue() (./kdegames/ksirtet/board.cpp:356)
bool Board::beforeGlue(bool bump, bool first)
{
if ( !bump ) return FALSE;
if (first) loop = 0;
else loop++;
float dec = blockHeight();
switch (loop) {
case 0: return TRUE;
case 1: dec *= -0.2; break;
case 2: dec *= -0.3; break;
}
if (_animations) bumpCurrentPiece((int)dec);
return ( loop!=3 );
}