Source Code (Use browser search to find items of interest.)
Class Index
kjumpingcube'KCubeBoxWidget (./kdegames/kjumpingcube/kcubeboxwidget.h:51)
class KCubeBoxWidget : public QWidget , public CubeBoxBase<KCubeWidget>
{
Q_OBJECT
public:
KCubeBoxWidget(int dim=1,QWidget *parent=0,const char *name=0);
KCubeBoxWidget(CubeBox& box, QWidget *parent=0,const char *name=0);
KCubeBoxWidget(const KCubeBoxWidget& box,QWidget *parent=0,const char *name=0);
virtual ~KCubeBoxWidget();
KCubeBoxWidget& operator= (CubeBox& box);
KCubeBoxWidget& operator= ( const KCubeBoxWidget& box);
/**
* reset cubebox for a new game
*/
void reset();
/** undo last move */
void undo();
/**
* computes a possibility to move and shows it by highlightning
* this cube
*/
void getHint();
/**
* set colors that are used to show owners of the cubes
*
* @param forWhom for which player the color should be set
* @param color color for player one
*/
void setColor(Player forWhom,QPalette color);
/**
* sets number of Cubes in a row/column to 'size'.
*/
virtual void setDim(int dim);
/**
* sets skill of computerplayer and 'getHint()'
*
* @return previous level
*/
void setSkill(Brain::Skill skill);
/**
* sets player 'player' as computer or human
*
* @param player
* @param flag: true for computer, false for human
*/
void setComputerplayer(Player player,bool flag);
/** returns current skill */
Brain::Skill skill() const;
/** returns true if player 'player' is a computerPlayer */
bool isComputer(Player player) const;
/** returns true if CubeBox is doing a move or getting a hint */
bool isActive() const;
bool isMoving() const;
/** returns current Color for Player ´forWhom´ */
QPalette color(Player forWhom);
/**
* checks if 'player' is a computerplayer an computes next move if TRUE
*/
void checkComputerplayer(Player player);
void saveGame(KConfigBase *);
void restoreGame(KConfigBase *);
public slots:
/** stops all activities like getting a hint or doing a move */
void stopActivities();
signals:
void playerChanged(int newPlayer);
void playerWon(int player);
void startedMoving();
void startedThinking();
void stoppedMoving();
void stoppedThinking();
protected:
virtual void deleteCubes();
virtual void initCubes();
protected slots:
/** sets the cursor to an waitcursor */
void setWaitCursor();
/** restores the original cursor */
void setNormalCursor();
private:
void init();
QGridLayout *layout;
CubeBox *undoBox;
Brain brain;
QTimer *moveTimer;
int moveDelay;
Loop loop;
/** */
void startLoop();
/** */
void stopLoop();
Player changePlayer();
bool hasPlayerWon(Player player);
bool computerPlOne;
bool computerPlTwo;
/**
* increases the cube at row 'row' and column 'column' ,
* and starts the Loop for checking the playingfield
*/
void doMove(int row,int column);
void increaseNeighbours(KCubeBoxWidget::Player forWhom,int row,int column);
private slots:
void nextLoopStep();
/**
* checks if cube at ['row','column'] is clickable by the current player.
* if true, it increases this cube and checks the playingfield
*/
bool checkClick(int row,int column);
/** turns off blinking, if an other cube is clicked */
void stopHint();
};
kjumpingcube'KCubeBoxWidget::KCubeBoxWidget() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:34)
KCubeBoxWidget::KCubeBoxWidget(const int d,QWidget *parent,const char *name)
: QWidget(parent,name),
CubeBoxBase<KCubeWidget>(d)
{
init();
}
kjumpingcube'KCubeBoxWidget::KCubeBoxWidget() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:43)
KCubeBoxWidget::KCubeBoxWidget(CubeBox& box,QWidget *parent,const char *name)
:QWidget(parent,name),
CubeBoxBase<KCubeWidget>(box.dim())
{
init();
int i,j;
for(i=0;i<dim();i++)
for(j=0;j<dim();j++)
{
*cubes[i][j]=*box[i][j];
}
currentPlayer=(KCubeBoxWidget::Player)box.player();
}
kjumpingcube'KCubeBoxWidget::KCubeBoxWidget() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:61)
KCubeBoxWidget::KCubeBoxWidget(const KCubeBoxWidget& box,QWidget *parent,const char *name)
:QWidget(parent,name),
CubeBoxBase<KCubeWidget>(box.dim())
{
init();
int i,j;
for(i=0;i<dim();i++)
for(j=0;j<dim();j++)
{
*cubes[i][j]=*box.cubes[i][j];
}
currentPlayer=box.currentPlayer;
}
kjumpingcube'KCubeBoxWidget::~KCubeBoxWidget() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:80)
KCubeBoxWidget::~KCubeBoxWidget()
{
if(cubes)
deleteCubes();
if(undoBox)
delete undoBox;
}
kjumpingcube'KCubeBoxWidget::reset() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:136)
void KCubeBoxWidget::reset()
{
stopActivities();
int i,j;
for(i=0;i<dim();i++)
for(j=0;j<dim();j++)
{
cubes[i][j]->reset();
}
KCubeWidget::enableClicks(true);
currentPlayer=One;
emit playerChanged(One);
checkComputerplayer(One);
}
kjumpingcube'KCubeBoxWidget::undo() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:156)
void KCubeBoxWidget::undo()
{
if(isActive())
return;
Player oldPlayer=currentPlayer;
*this=*undoBox;
if(oldPlayer!=currentPlayer)
emit playerChanged(currentPlayer);
checkComputerplayer(currentPlayer);
}
kjumpingcube'KCubeBoxWidget::getHint() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:172)
void KCubeBoxWidget::getHint()
{
if(isActive())
return;
int d=dim();
for(int i=0;i<d;i++)
for(int j=0;j<d;j++)
{
cubes[i][j]->stopHint();
}
int row=0,column=0;
CubeBox field=*this;
emit startedThinking();
bool canceled=!brain.getHint(row,column,(CubeBox::Player)currentPlayer,field);
emit stoppedThinking();
if(canceled)
{
return; // return if thinking was stopped
}
cubes[row][column]->showHint();
}
kjumpingcube'KCubeBoxWidget::setColor() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:198)
void KCubeBoxWidget::setColor(Player player,QPalette color)
{
KCubeWidget::setColor((Cube::Owner)player,color);
for(int row=0;row<dim();row++)
for(int col=0;col<dim();col++)
{
cubes[row][col]->updateColors();
}
}
kjumpingcube'KCubeBoxWidget::setDim() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:209)
void KCubeBoxWidget::setDim(int d)
{
if(d != dim())
{
undoBox->setDim(d);
CubeBoxBase<KCubeWidget>::setDim(d);
}
}
kjumpingcube'KCubeBoxWidget::setSkill() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:218)
void KCubeBoxWidget::setSkill(Brain::Skill skill)
{
brain.setSkill(skill);
}
kjumpingcube'KCubeBoxWidget::setComputerplayer() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:224)
void KCubeBoxWidget::setComputerplayer(Player player,bool flag)
{
if(player==One)
computerPlOne=flag;
else if(player==Two)
computerPlTwo=flag;
checkComputerplayer(player);
}
kjumpingcube'KCubeBoxWidget::stopActivities() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:235)
void KCubeBoxWidget::stopActivities()
{
if(moveTimer->isActive())
{
stopLoop();
emit stoppedMoving();
}
if(brain.isActive())
{
brain.stop();
emit stoppedThinking();
}
}
kjumpingcube'KCubeBoxWidget::saveGame() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:251)
void KCubeBoxWidget::saveGame(KConfigBase* config)
{
if(isMoving())
{
stopActivities();
undo();
}
else if(brain.isActive())
stopActivities();
// save current player
config->writeEntry("onTurn",(int)currentPlayer);
QStrList list;
list.setAutoDelete(true);
QString owner, value, key;
int cubeDim=dim();
for(int row=0; row < cubeDim ; row++)
for(int column=0; column < cubeDim ; column++)
{
key.sprintf("%u,%u",row,column);
owner.sprintf("%u",cubes[row][column]->owner());
value.sprintf("%u",cubes[row][column]->value());
list.append(owner.ascii());
list.append(value.ascii());
config->writeEntry(key , list);
list.clear();
}
}
kjumpingcube'KCubeBoxWidget::restoreGame() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:283)
void KCubeBoxWidget::restoreGame(KConfigBase* config)
{
QStrList list;
list.setAutoDelete(true);
QString owner, value, key;
int cubeDim=dim();
for(int row=0; row < cubeDim ; row++)
for(int column=0; column < cubeDim ; column++)
{
key.sprintf("%u,%u",row,column);
config->readListEntry(key, list);
owner=list.first();
value=list.next();
cubes[row][column]->setOwner((KCubeWidget::Owner)owner.toInt());
cubes[row][column]->setValue(value.toInt());
list.clear();
}
// set current player
int onTurn=config->readNumEntry("onTurn",1);
currentPlayer=(Player)onTurn;
emit playerChanged(onTurn);
checkComputerplayer((Player)onTurn);
}
/* ***************************************************************** **
** slots **
** ***************************************************************** */
kjumpingcube'KCubeBoxWidget::setWaitCursor() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:315)
void KCubeBoxWidget::setWaitCursor()
{
setCursor(KCursor::waitCursor());
}
kjumpingcube'KCubeBoxWidget::setNormalCursor() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:322)
void KCubeBoxWidget::setNormalCursor()
{
setCursor(KCursor::handCursor());
}
kjumpingcube'KCubeBoxWidget::stopHint() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:328)
void KCubeBoxWidget::stopHint()
{
int d=dim();
for(int i=0;i<d;i++)
for(int j=0;j<d;j++)
{
cubes[i][j]->stopHint();
}
}
kjumpingcube'KCubeBoxWidget::checkClick() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:341)
bool KCubeBoxWidget::checkClick(int row,int column)
{
if(isActive())
return false;
if((Cube::Owner)currentPlayer==cubes[row][column]->owner() ||
cubes[row][column]->owner()==Cube::Nobody)
{
doMove(row,column);
return true;
}
else
return false;
}
kjumpingcube'KCubeBoxWidget::checkComputerplayer() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:358)
void KCubeBoxWidget::checkComputerplayer(Player player)
{
// checking if a process is running or the Widget isn't shown yet
if(isActive() || !isVisibleToTLW())
return;
if((player==One && computerPlOne && currentPlayer==One)
|| (player==Two && computerPlTwo && currentPlayer==Two))
{
KCubeWidget::enableClicks(false);
CubeBox field(*this);
int row=0,column=0;
emit startedThinking();
bool canceled=!brain.getHint(row,column,(CubeBoxBase<Cube>::Player)player,field);
emit stoppedThinking();
if(!canceled)
{
cubes[row][column]->showHint(500,2);
assert(checkClick(row,column));
}
}
}
/* ***************************************************************** **
** status functions **
** ***************************************************************** */
kjumpingcube'KCubeBoxWidget::isActive() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:388)
bool KCubeBoxWidget::isActive() const
{
bool flag=false;
if(moveTimer->isActive())
flag=true;
else if(brain.isActive())
flag=true;
return flag;
}
kjumpingcube'KCubeBoxWidget::isMoving() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:399)
bool KCubeBoxWidget::isMoving() const
{
return moveTimer->isActive();
}
kjumpingcube'KCubeBoxWidget::isComputer() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:404)
bool KCubeBoxWidget::isComputer(Player player) const
{
if(player==One)
return computerPlOne;
else
return computerPlTwo;
}
Brain::Skill KCubeBoxWidget::skill() const
{
Brain::Skill skill=brain.skill();
return skill;
}
kjumpingcube'KCubeBoxWidget::color() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:419)
QPalette KCubeBoxWidget::color(Player forWhom)
{
return KCubeWidget::color((KCubeWidget::Owner)forWhom);
}
/* ***************************************************************** **
** initializing functions **
** ***************************************************************** */
kjumpingcube'KCubeBoxWidget::init() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:427)
void KCubeBoxWidget::init()
{
initCubes();
undoBox=new CubeBox(dim());
currentPlayer=One;
moveDelay=500;
moveTimer=new QTimer(this);
computerPlOne=false;
computerPlTwo=false;
KCubeWidget::enableClicks(true);
connect(moveTimer,SIGNAL(timeout()),SLOT(nextLoopStep()));
connect(this,SIGNAL(startedThinking()),SLOT(setWaitCursor()));
connect(this,SIGNAL(stoppedThinking()),SLOT(setNormalCursor()));
connect(this,SIGNAL(startedMoving()),SLOT(setWaitCursor()));
connect(this,SIGNAL(stoppedMoving()),SLOT(setNormalCursor()));
connect(this,SIGNAL(playerWon(int)),SLOT(stopActivities()));
setNormalCursor();
emit playerChanged(One);
}
kjumpingcube'KCubeBoxWidget::initCubes() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:453)
void KCubeBoxWidget::initCubes()
{
const int s=dim();
int i,j;
// create Layout
layout=new QGridLayout(this,s,s);
for(i=0;i<s;i++)
{
layout->setRowStretch(i,1);
layout->setColStretch(i,1);
}
// create new cubes
cubes = new KCubeWidget**[s];
for(i=0;i<s;i++)
{
cubes[i]=new KCubeWidget*[s];
}
for(i=0;i<s;i++)
for(j=0;j<s;j++)
{
cubes[i][j]=new KCubeWidget(this);
cubes[i][j]->setCoordinates(i,j);
layout->addWidget(cubes[i][j],i,j);
cubes[i][j]->show();
connect(cubes[i][j],SIGNAL(clicked(int,int)),SLOT(stopHint()));
connect(cubes[i][j],SIGNAL(clicked(int,int)),SLOT(checkClick(int,int)));
}
// initialize cubes
int max=dim()-1;
cubes[0][0]->setMax(2);
cubes[0][max]->setMax(2);
cubes[max][0]->setMax(2);
cubes[max][max]->setMax(2);
for(i=1;i<max;i++)
{
cubes[i][0]->setMax(3);
cubes[i][max]->setMax(3);
cubes[0][i]->setMax(3);
cubes[max][i]->setMax(3);
}
for(i=1;i<max;i++)
for(j=1;j<max;j++)
{
cubes[i][j]->setMax(4);
}
}
kjumpingcube'KCubeBoxWidget::deleteCubes() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:510)
void KCubeBoxWidget::deleteCubes()
{
if(layout)
delete layout;
CubeBoxBase<KCubeWidget>::deleteCubes();
}
/* ***************************************************************** **
** other private functions **
** ***************************************************************** */
kjumpingcube'KCubeBoxWidget::doMove() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:523)
void KCubeBoxWidget::doMove(int row,int column)
{
// if a move hasn't finished yet don't do another move
if(isActive())
return;
// for undo-function copy field
*undoBox=*this;
cubes[row][column]->increase((Cube::Owner)currentPlayer);
if(cubes[row][column]->overMax())
{
KCubeWidget::enableClicks(false);
startLoop();
}
else
changePlayer();
}
kjumpingcube'KCubeBoxWidget::startLoop() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:543)
void KCubeBoxWidget::startLoop()
{
emit startedMoving();
KCubeWidget::enableClicks(false);
loop.row=0;
loop.column=0;
loop.finished=true;
moveTimer->start(moveDelay);
}
kjumpingcube'KCubeBoxWidget::stopLoop() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:557)
void KCubeBoxWidget::stopLoop()
{
moveTimer->stop();
emit stoppedMoving();
KCubeWidget::enableClicks(true);
}
kjumpingcube'KCubeBoxWidget::nextLoopStep() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:565)
void KCubeBoxWidget::nextLoopStep()
{
// search cube with to many points
while(!cubes[loop.row][loop.column]->overMax())
{
loop.column++;
if(loop.column==dim())
{
if(loop.row==dim()-1)
{
if(!loop.finished)
{
loop.row=0;
loop.column=0;
loop.finished=true;
return;
}
else // loop finished
{
stopLoop();
changePlayer();
return;
}
}
else
{
loop.row++;
loop.column=0;
}
}
}
increaseNeighbours(currentPlayer,loop.row,loop.column);
cubes[loop.row][loop.column]->decrease();
loop.finished=false;
if(hasPlayerWon(currentPlayer))
{
emit playerWon((int)currentPlayer);
stopLoop();
return;
}
}
kjumpingcube'KCubeBoxWidget::hasPlayerWon() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:612)
bool KCubeBoxWidget::hasPlayerWon(Player player)
{
for(int i=0;i<dim();i++)
for(int j=0;j<dim();j++)
{
if(cubes[i][j]->owner()!=(Cube::Owner)player)
{
return false;
}
}
return true;
}
KCubeBoxWidget::Player KCubeBoxWidget::changePlayer()
{
currentPlayer=(currentPlayer==One)? Two : One;
emit playerChanged(currentPlayer);
checkComputerplayer(currentPlayer);
KCubeWidget::enableClicks(true);
return currentPlayer;
}
kjumpingcube'KCubeBoxWidget::increaseNeighbours() (./kdegames/kjumpingcube/kcubeboxwidget.cpp:636)
void KCubeBoxWidget::increaseNeighbours(KCubeBoxWidget::Player forWhom,int row,int column)
{
KCubeWidget::Owner _player = (KCubeWidget::Owner)(forWhom);
if(row==0)
{
if(column==0) // top left corner
{
cubes[0][1]->increase(_player);
cubes[1][0]->increase(_player);
return;
}
else if(column==dim()-1) // top right corner
{
cubes[0][dim()-2]->increase(_player);
cubes[1][dim()-1]->increase(_player);
return;
}
else // top edge
{
cubes[0][column-1]->increase(_player);
cubes[0][column+1]->increase(_player);
cubes[1][column]->increase(_player);
return;
}
}
else if(row==dim()-1)
{
if(column==0) // left bottom corner
{
cubes[dim()-2][0]->increase(_player);
cubes[dim()-1][1]->increase(_player);
return;
}
else if(column==dim()-1) // right bottom corner
{
cubes[dim()-2][dim()-1]->increase(_player);
cubes[dim()-1][dim()-2]->increase(_player);
return;
}
else // bottom edge
{
cubes[dim()-1][column-1]->increase(_player);
cubes[dim()-1][column+1]->increase(_player);
cubes[dim()-2][column]->increase(_player);
return;
}
}
else if(column==0) // left edge
{
cubes[row-1][0]->increase(_player);
cubes[row+1][0]->increase(_player);
cubes[row][1]->increase(_player);
return;
}
else if(column==dim()-1) // right edge
{
cubes[row-1][dim()-1]->increase(_player);
cubes[row+1][dim()-1]->increase(_player);
cubes[row][dim()-2]->increase(_player);
return;
}
else
{
cubes[row][column-1]->increase(_player);
cubes[row][column+1]->increase(_player);
cubes[row-1][column]->increase(_player);
cubes[row+1][column]->increase(_player);
return;
}
}