summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/games/zsame/StoneField.cpp4
-rw-r--r--noncore/games/zsame/StoneField.h3
-rw-r--r--noncore/games/zsame/StoneWidget.cpp4
-rw-r--r--noncore/games/zsame/StoneWidget.h1
-rw-r--r--noncore/games/zsame/ZSameWidget.cpp1
5 files changed, 12 insertions, 1 deletions
diff --git a/noncore/games/zsame/StoneField.cpp b/noncore/games/zsame/StoneField.cpp
index 49d8eca..56e9dc5 100644
--- a/noncore/games/zsame/StoneField.cpp
+++ b/noncore/games/zsame/StoneField.cpp
@@ -1,390 +1,394 @@
/*
* ksame 0.4 - simple Game
* Copyright (C) 1997,1998 Marcus Kreutzberger
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
#include "StoneField.h"
#include <assert.h>
StoneFieldState::StoneFieldState(const StoneField &stonefield)
{
field=new unsigned char[stonefield.maxstone];
for (int i=0;i<stonefield.maxstone;i++)
field[i]=stonefield.field[i].color;
colors=stonefield.colors;
board=stonefield.board;
score=stonefield.score;
gameover=stonefield.gameover;
}
StoneFieldState::~StoneFieldState() {
delete[] field;
}
void
StoneFieldState::restore(StoneField &stonefield) const {
for (int i=0;i<stonefield.maxstone;i++) {
stonefield.field[i].color=field[i];
stonefield.field[i].changed=true;
stonefield.field[i].marked=false;
}
stonefield.colors=colors;
stonefield.board=board;
stonefield.score=score;
stonefield.marked=0;
stonefield.gameover=gameover;
}
StoneField::StoneField(int width, int height,
int colors, unsigned int board,
bool undoenabled)
{
// Q_ASSERT(width>0);
// Q_ASSERT(height>0);
if (undoenabled) undolist=new QList<StoneFieldState>;
else undolist=0;
sizex=width;
sizey=height;
maxstone=sizex*sizey;
field=new Stone[maxstone];
newGame(board,colors);
m_gotBonus= false;
}
StoneField::~StoneField() {
delete[] field;
delete undolist;
// kdDebug() << "~StoneField\n" << endl;
}
int
StoneField::width() const {
return sizex;
}
int
StoneField::height() const {
return sizey;
}
void
StoneField::newGame(unsigned int board,int colors) {
// kdDebug() << "StoneField::newgame board "
// << board << " colors " << colors << endl;
if (colors<1) colors=3;
if (colors>7) colors=7;
this->colors=colors;
this->board=board;
reset();
}
void
StoneField::reset() {
random.setSeed(board);
Stone *stone=field;
for (int i=0;i<maxstone;i++,stone++) {
stone->color=1+random.getLong(colors);
stone->marked=false;
stone->changed=true;
}
gameover=-1;
score=0;
marked=0;
if (undolist) {
undolist->setAutoDelete(true);
undolist->clear();
}
int c[7];
int j;
for (j=0;j<7;j++) c[j]=0;
for (j=0,stone=field;j<maxstone;j++,stone++) {
c[stone->color]++;
}
// kdDebug() << "red " << c[1] << endl;
// kdDebug() << "blue " << c[2] << endl;
// kdDebug() << "yellow " << c[3] << endl;
// kdDebug() << "green " << c[4] << endl;
}
int
StoneField::map(int x,int y) {
assert (!(x<0||y<0||x>=sizex||y>=sizey));
return x+y*sizex;
}
int
StoneField::mark(int x,int y,bool force) {
int index=map(x,y);
if (index<0) {
unmark();
return 0;
}
if (field[index].marked) return -1;
unmark();
mark(index,field[index].color);
if (marked==1&&!force) {
field[index].marked=false;
marked=0;
}
return marked;
}
void
StoneField::mark(int index,unsigned char color) {
if ( index<0 || index>=maxstone ) return;
Stone &stone=field[index];
if (stone.marked) return;
if (!stone.color || stone.color!=color) return;
stone.changed=true;
stone.marked=true;
marked++;
// mark left
if ((index%sizex)!=0) mark(index-1,color);
// mark right
if (((index+1)%sizex)!=0) mark(index+1,color);
// mark upward
if (index>=sizex) mark(index-sizex,color);
// mark downward
if (index<(sizex-1)*sizey) mark(index+sizex,color);
}
void
StoneField::unmark() {
if (!marked) return;
Stone *stone=field;
for (int i=0;i<maxstone;i++,stone++) {
stone->marked=false;
stone->changed=true;
}
marked=0;
}
int
StoneField::remove(int x,int y,bool force) {
int index=map(x,y);
if (index<0) return 0;
if (!field[index].marked) {
mark(x,y,force);
}
if (!marked) return 0;
// remove a single stone??
if (marked==1&&!force) return 0;
// add current field to undolist
if (undolist)
undolist->append(new StoneFieldState(*this));
// increase score
if (marked>2)
score+=(marked-2)*(marked-2);
// remove marked stones
Stone *stone=field;
for (int i=0;i<maxstone;i++,stone++) {
if (stone->marked) {
stone->color=0;
stone->changed=true;
stone->marked=false;
}
}
int removed=marked;
marked=0;
for (int col=0;col<sizex;col++) {
int i1=col+maxstone-sizex;
while ( i1>=0 && field[i1].color ) i1-=sizex;
int i2=i1;
while (i2>=0) {
while ( i2>=0 && !field[i2].color ) i2-=sizex;
while ( i2>=0 && field[i2].color ) {
field[i1].color=field[i2].color;
field[i1].changed=true;
field[i2].color=0;
field[i2].changed=true;
i1-=sizex;
i2-=sizex;
}
}
}
// find the last column that has something
int lastcol = sizex;
while (lastcol > 0 && !field[map(lastcol-1, sizey-1)].color) {
lastcol--;
}
for (int col=0;col<lastcol-1;) {
bool empty = true;
for (int row = 0; row < sizey; row++)
if (field[map(col, row)].color) {
empty = false;
break;
}
if (!empty) {
col++;
continue;
}
int nextfullcol = col + 1;
while (nextfullcol < sizex &&
!field[map(nextfullcol, sizey - 1)].color)
nextfullcol++;
if (nextfullcol > sizex - 1)
break; // we're ready
for (int row=0; row < sizey; row++) {
int source = map(nextfullcol, row);
int dest = map(col, row);
field[dest].color=field[source].color;
field[dest].changed=true;
field[source].color=0;
field[source].changed=true;
}
}
// add a bonus, if field is empty
if (!field[map(0, sizey-1)].color) {
score+=1000;
m_gotBonus= true;
}
// gameover is undefined
gameover=-1;
return removed;
}
bool StoneField::undoPossible() const {
return !(!undolist||undolist->isEmpty());
}
int
StoneField::undo(int count) {
if (!undoPossible())
return 0;
if (count <= 0)
return 0;
int undocount=1;
StoneFieldState *state=0;
undolist->setAutoDelete(true);
while (--count>0) {
if (undolist->count()==1) break;
undolist->removeLast();
undocount++;
}
state=undolist->getLast();
// Q_ASSERT(state);
state->restore(*this);
undolist->removeLast();
return undocount;
}
bool
StoneField::isGameover() const {
register int i=maxstone-1;;
register unsigned char color;
if (gameover>=0) return (bool)gameover;
// kdDebug() << "-->gameover" << endl;
while (i>=0) {
// kdDebug() << i << " " << field[i].color << endl;
// ignore empty fields
while ( i>=0 && field[i].color==0 ) i--;
// Wenn Stein gefunden,
// dann die Nachbarn auf gleiche Farbe pruefen.
while ( i>=0 && (color=field[i].color) ) {
// check left
if ( (i%sizex)!=0 && field[i-1].color==color)
goto check_gameover;
// check upward
if ( i>=sizex && field[i-sizex].color==color)
goto check_gameover;
i--;
}
}
check_gameover:
gameover=(i<0);
// kdDebug() << "<--gameover" << endl;
return (bool)gameover;
}
bool StoneField::gotBonus() const {
return m_gotBonus;
}
+void StoneField::clearBonus() {
+ m_gotBonus = false;
+}
+
int
StoneField::getBoard() const {
return board;
}
int
StoneField::getScore() const {
return score;
}
int
StoneField::getColors() const {
return colors;
}
int
StoneField::getMarked() const {
return marked;
}
int
StoneField::getFieldSize() const {
return maxstone;
}
struct Stone *
StoneField::getField() const {
return field;
}
diff --git a/noncore/games/zsame/StoneField.h b/noncore/games/zsame/StoneField.h
index 80be73a..d32d78d 100644
--- a/noncore/games/zsame/StoneField.h
+++ b/noncore/games/zsame/StoneField.h
@@ -1,113 +1,114 @@
/* Yo Emacs, this is -*- C++ -*- */
/*
* ksame 0.4 - simple Game
* Copyright (C) 1997,1998 Marcus Kreutzberger
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
#ifndef _STONEFIELD
#define _STONEFIELD
#include <krandomsequence.h>
#include <qlist.h>
struct Stone {
unsigned char color;
bool changed;
bool marked;
};
class StoneField;
class StoneWidget;
class StoneFieldState {
private:
unsigned char *field;
int colors;
unsigned int board;
unsigned int score;
int gameover;
public:
StoneFieldState(const StoneField &stonefield);
~StoneFieldState();
void restore(StoneField &stonefield) const;
};
class StoneField {
friend class StoneFieldState;
friend class StoneWidget;
private:
int sizex;
int sizey;
int maxstone;
struct Stone *field;
int colors;
unsigned int board;
unsigned int score;
mutable int gameover;
bool m_gotBonus;
int marked;
KRandomSequence random;
QList<StoneFieldState> *undolist;
public:
StoneField(int width=15,int height=10,
int colors=3,unsigned int board=0,
bool undoenabled=true);
~StoneField();
int width() const;
int height() const;
void newGame(unsigned int board,int colors);
void reset();
int mark(int x,int y,bool force=false);
void unmark();
int remove(int x,int y,bool force=false);
int undo(int count=1);
- bool isGameover() const;
+ bool isGameover() const;
bool gotBonus() const;
+ void clearBonus();
bool undoPossible() const;
int getBoard() const;
int getScore() const;
int getColors() const;
int getMarked() const;
protected:
int getFieldSize() const;
struct Stone *getField() const;
int map(int x,int y);
void mark(int index,unsigned char color);
};
#endif
diff --git a/noncore/games/zsame/StoneWidget.cpp b/noncore/games/zsame/StoneWidget.cpp
index 646fc9c..5dd0252 100644
--- a/noncore/games/zsame/StoneWidget.cpp
+++ b/noncore/games/zsame/StoneWidget.cpp
@@ -1,345 +1,349 @@
/*
* ksame 0.4 - simple Game
* Copyright (C) 1997,1998 Marcus Kreutzberger
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <qpe/resource.h>
#include <time.h>
#include <assert.h>
#include "StoneWidget.h"
struct StoneSlice {
QPixmap stone;
};
StoneWidget::StoneWidget( QWidget *parent, int x, int y )
: QWidget(parent,"StoneWidget"), stonefield(x,y)
{
// setBackgroundPixmap(QPixmap(locate("wallpaper", "Time-For-Lunch-2.jpg")));
// QPixmap stonemap(locate("appdata", "stones.png"));
QPixmap stonemap = Resource::loadPixmap("zsame/stones" );
assert(!stonemap.isNull());
slice=0;
maxslices=30;
maxcolors=4;
sizex=x;
sizey=y;
stone_width=stonemap.width()/(maxslices+1);
stone_height=stonemap.height()/maxcolors;
map = new StoneSlice*[maxcolors];
QBitmap mask;
for (int c = 0; c < maxcolors; c++) {
map[c] = new StoneSlice[maxslices];
for (int s = 0; s < maxslices; s++) {
map[c][s].stone.resize(stone_width, stone_height);
assert(!map[c][s].stone.isNull());
bitBlt(&map[c][s].stone, 0, 0,
&stonemap, stone_width * s,
c*stone_height,
stone_width,stone_height,CopyROP,false);
QImage im = map[c][s].stone.convertToImage();
mask = im.createHeuristicMask();
map[c][s].stone.setMask(mask);
}
}
field_height=stone_height*sizey;
field_width=stone_width*sizex;
setMouseTracking(true);
// QColor c(115,115,115);
// setBackgroundColor(c);
// emit s_sizechanged();
startTimer( 100 );
history.setAutoDelete(true);
}
StoneWidget::~StoneWidget() {
for (int c = 0; c < maxcolors; c++) {
delete [] map[c];
}
delete [] map;
setMouseTracking(false);
killTimers();
}
unsigned int
StoneWidget::board() {
return stonefield.getBoard();
}
int
StoneWidget::score() {
return stonefield.getScore();
}
int
StoneWidget::marked() {
return stonefield.getMarked();
}
QSize
StoneWidget::size() {
return QSize(sizex,sizey);
}
int
StoneWidget::colors() {
return stonefield.getColors();
}
QSize
StoneWidget::sizeHint () const {
return QSize(field_width,field_height);
}
void
StoneWidget::newGame(unsigned int board,int colors) {
stonefield.newGame(board,colors);
history.clear();
modified= false;
emit s_newgame();
emit s_colors(stonefield.getColors());
emit s_board(stonefield.getBoard());
}
void
StoneWidget::reset() {
stonefield.reset();
history.clear();
emit s_newgame();
}
void
StoneWidget::unmark() {
stonefield.unmark();
emit s_marked(0);
}
bool StoneWidget::undoPossible() const {
if (stonefield.isGameover()) return false;
return stonefield.undoPossible();
}
int
StoneWidget::undo(int count) {
if (stonefield.isGameover()) return 0;
int ret_val=stonefield.undo(count);
QPoint p=mapFromGlobal(cursor().pos());
int x=p.x();
int y=p.y();
if (x<0||y<0||x>=field_width||y>=field_height) {
emit s_score(stonefield.getMarked());
return ret_val;
}
int marked=stonefield.mark(x/stone_width,y/stone_height);
emit s_marked(marked);
slice=0;
emit s_score(stonefield.getScore());
modified= (stonefield.getScore()>0);
return ret_val;
}
bool StoneWidget::isGameover() {
return stonefield.isGameover();
}
bool StoneWidget::hasBonus() {
return stonefield.gotBonus(); // don't ask me why the names differ... ;-| [hlm]
}
+void StoneWidget::clearBonus() {
+ stonefield.clearBonus();
+}
+
bool StoneWidget::isOriginalBoard() {
return !modified;
}
void StoneWidget::readProperties(Config *) {
/* Q_ASSERT(conf);
history.clear();
if (!conf->hasKey("Board")||
!conf->hasKey("Colors")||
!conf->hasKey("Stones")) {
return;
}
newGame(conf->readNumEntry("Board"),conf->readNumEntry("Colors"));
QStrList list;
conf->readListEntry("Stones",list);
for (const char *item=list.first();item;item=list.next()) {
int x=-1,y=-1;
if (sscanf(item,"%02X%02X",&x,&y)!=2) break;
history.append(new QPoint(x,y));
stonefield.remove(x,y);
}
*/
}
void
StoneWidget::saveProperties(Config *) {
/*
Q_ASSERT(conf);
QStrList list(true);
QString tmp;
for (QPoint *item=history.first();item;item=history.next()) {
tmp.sprintf("%02X%02X",item->x(),item->y());
list.append(tmp.ascii());
}
conf->writeEntry("Stones",list);
conf->writeEntry("Board",stonefield.getBoard());
conf->writeEntry("Colors",stonefield.getColors());
*/
}
void
StoneWidget::timerEvent( QTimerEvent * ) {
QPoint p=mapFromGlobal(cursor().pos());
int x=p.x();
int y=p.y();
if (x<0||y<0||x>=field_width||y>=field_height)
stonefield.unmark();
slice=(slice+1)%maxslices;
paintEvent(0);
}
void
StoneWidget::paintEvent( QPaintEvent *e ) {
Stone *stone=stonefield.getField();
for (int y=0;y<sizey;y++) {
int cy = y * stone_height;
for (int x=0;x<sizex;x++) {
int cx = stone_width * x;
bool redraw=stone->marked||stone->changed;
if (!redraw&&e) {
QRect r(cx,cy,stone_width,stone_height);
redraw=r.intersects(e->rect());
}
if (redraw) {
stone->changed=false;
if (stone->color) {
int tslice = stone->marked?slice:0;
bitBlt(this,cx,cy,
&map[stone->color-1][tslice].stone,
0, 0,
stone_width,stone_height,CopyROP,FALSE);
} else {
erase(cx, cy, stone_width, stone_height);
}
}
stone++; // naechster Stein.
}
}
}
void
StoneWidget::mousePressEvent ( QMouseEvent *e) {
if (stonefield.isGameover()) return;
int x=e->pos().x();
int y=e->pos().y();
if (x<0||y<0||x>=field_width||y>=field_height) return;
int sx=x/stone_width;
int sy=y/stone_height;
int mar =stonefield.mark(sx, sy);
if ( mar != -1 ) {
myMoveEvent(e);
return;
}
if (stonefield.remove(sx, sy)) {
history.append(new QPoint(sx, sy));
emit s_remove(sx, sy);
stonefield.mark(sx,sy);
emit s_marked(stonefield.getMarked());
modified= true;
emit s_score(stonefield.getScore());
if (stonefield.isGameover()) emit s_gameover();
}
}
void
StoneWidget::myMoveEvent ( QMouseEvent *e)
{
return;
if (stonefield.isGameover()) {
stonefield.unmark();
emit s_marked(0);
return;
}
int x=e->pos().x();
int y=e->pos().y();
if (x<0||y<0||x>=field_width||y>=field_height) return;
int marked=stonefield.mark(x/stone_width,y/stone_height);
if (marked>=0) {
emit s_marked(marked);
slice=0;
}
}
diff --git a/noncore/games/zsame/StoneWidget.h b/noncore/games/zsame/StoneWidget.h
index 9cd7e10..89a8afc 100644
--- a/noncore/games/zsame/StoneWidget.h
+++ b/noncore/games/zsame/StoneWidget.h
@@ -1,115 +1,116 @@
/* Yo Emacs, this is -*- C++ -*- */
/*
* ksame 0.4 - simple Game
* Copyright (C) 1997,1998 Marcus Kreutzberger
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
#ifndef _STONEWIDGET
#define _STONEWIDGET
#include <qpixmap.h>
#include <qwidget.h>
#include <qpe/config.h>
#include "StoneField.h"
struct StoneSlice;
class StoneWidget : public QWidget {
Q_OBJECT
int modified;
// int marked; // # of marked stones
int stones_x, stones_y;
int sizex, sizey;
int field_width, field_height;
QList<QPoint> history;
StoneField stonefield;
// picture number of stonemovie
int slice;
StoneSlice **map;
public:
StoneWidget( QWidget *parent=0, int x=10,int y=10);
~StoneWidget();
unsigned int board();
int score();
int marked();
QSize size();
int colors();
virtual QSize sizeHint() const;
bool undoPossible() const;
void newGame(unsigned int board, int colors);
void reset();
void unmark();
int undo(int count=1);
// test for game end
bool isGameover();
// if isGameover(): finished with bonus?
bool hasBonus();
+ void clearBonus();
// test for unchanged start position
bool isOriginalBoard();
virtual void readProperties(Config *conf);
virtual void saveProperties(Config *conf);
protected:
void timerEvent( QTimerEvent *e );
void paintEvent( QPaintEvent *e );
void mousePressEvent ( QMouseEvent *e);
void myMoveEvent ( QMouseEvent *e);
// properties of the stone picture
int stone_width,stone_height; // size of one stone
int maxcolors; // number of different stones (Y direction)
int maxslices; // number of pictures per movie (X direction)
signals:
// A new game begins
void s_newgame();
void s_colors(int colors);
void s_board(int board);
void s_score(int score);
void s_marked(int m);
void s_gameover();
// The stone (x,y) was clicked(removed),
// all neighbor stones disappear without further signals
void s_remove(int x,int y);
void s_sizechanged();
};
#endif
diff --git a/noncore/games/zsame/ZSameWidget.cpp b/noncore/games/zsame/ZSameWidget.cpp
index 04ad825..dee4a1c 100644
--- a/noncore/games/zsame/ZSameWidget.cpp
+++ b/noncore/games/zsame/ZSameWidget.cpp
@@ -1,244 +1,245 @@
/* Yo Emacs, this is -*- C++ -*- */
/*
* ksame 0.4 - simple Game
* Copyright (C) 1997,1998 Marcus Kreutzberger
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*/
#include <stdio.h>
#include <opie2/oapplicationfactory.h>
#include <qpe/resource.h>
#include <qtoolbar.h>
#include <qmenubar.h>
#include <qapplication.h>
#include <qaction.h>
#include <qmessagebox.h>
#include <kapplication.h>
#include "ZSameWidget.h"
static int default_colors=3;
#define i18n tr
using namespace Opie::Core;
OPIE_EXPORT_APP( OApplicationFactory<ZSameWidget> )
ZSameWidget::ZSameWidget( QWidget* parent, const char* name, WFlags fl )
: QMainWindow( parent, name, fl )
{
setCaption(tr("ZSame"));
setToolBarsMovable( false );
QToolBar* con = new QToolBar( this );
con->setHorizontalStretchable( true );
QMenuBar* mb = new QMenuBar( con );
QToolBar* tb = new QToolBar( this );
QPopupMenu* fileMenu = new QPopupMenu( this );
QAction* a = new QAction(tr("New Game"), Resource::loadIconSet("new") ,
QString::null, 0, this, "new_icon");
a->addTo( fileMenu );
a->addTo( tb );
connect(a, SIGNAL(activated()), this, SLOT(m_new()));
a = new QAction(tr("Restart This Board"), Resource::loadIconSet("redo"),
QString::null, 0, this, "restart_board" );
a->addTo( fileMenu );
connect( a, SIGNAL(activated()), this, SLOT(m_restart()));
restart = a;
a = new QAction( tr("Undo"), Resource::loadIconSet("undo"),
QString::null, 0, this, "undo_action" );
a->addTo( fileMenu );
a->addTo( tb );
connect( a, SIGNAL(activated()), this, SLOT(m_undo()));
a = new QAction(tr("Quit"), Resource::loadIconSet("quit_icon"),
QString::null, 0, this, "quit_action");
a->addTo( fileMenu );
a->addTo( tb );
connect(a, SIGNAL(activated()), this, SLOT(m_quit()));
mb->insertItem(tr("Game" ), fileMenu );
int foo[2];
desktop_widget(foo);
stone = new StoneWidget(this,foo[0],foo[1]);
connect( stone, SIGNAL(s_gameover()), this, SLOT(gameover()));
connect( stone, SIGNAL(s_colors(int)), this, SLOT(setColors(int)));
connect( stone, SIGNAL(s_board(int)), this, SLOT(setBoard(int)));
connect( stone, SIGNAL(s_marked(int)), this, SLOT(setMarked(int)));
connect( stone, SIGNAL(s_score(int)), this, SLOT(setScore(int)));
connect( stone, SIGNAL(s_remove(int,int)), this, SLOT(stonesRemoved(int,int)));
connect(stone, SIGNAL(s_sizechanged()), this, SLOT(sizeChanged()));
sizeChanged();
setCentralWidget(stone);
setScore(0);
}
ZSameWidget::~ZSameWidget() {
}
void ZSameWidget::readProperties(Config *) {
/*
Q_ASSERT(conf);
stone->readProperties(conf);
*/
}
void ZSameWidget::saveProperties(Config *) {
/*
Q_ASSERT(conf);
stone->saveProperties(conf);
conf->sync();
*/
}
void ZSameWidget::sizeChanged() {
// stone->setFixedSize(stone->sizeHint());
}
void ZSameWidget::newGame(unsigned int board,int colors) {
while (board>=1000000) board-=1000000;
// kdDebug() << "newgame board " << board << " colors " << colors << endl;
stone->newGame(board,colors);
setScore(0);
}
bool ZSameWidget::confirmAbort() {
return stone->isGameover() ||
stone->isOriginalBoard() ||
(QMessageBox::warning(this, i18n("Resign"), i18n("<qt>Do you want to resign?</qt>"),
QMessageBox::Yes,
QMessageBox::No|QMessageBox::Default|QMessageBox::Escape, 0) == QMessageBox::Yes );
}
void ZSameWidget::m_new() {
if (confirmAbort())
newGame(_random(),default_colors);
}
void ZSameWidget::m_restart() {
if (confirmAbort())
newGame(stone->board(),default_colors);
}
void ZSameWidget::m_load() {
// kdDebug() << "menu load not supported" << endl;
}
void ZSameWidget::m_save() {
// kdDebug() << "menu save not supported" << endl;
}
void ZSameWidget::m_undo() {
// Q_ASSERT(stone);
stone->undo();
}
void ZSameWidget::m_showhs() {
/* Q_ASSERT(stone);
stone->unmark();
KScoreDialog d(KScoreDialog::Name | KScoreDialog::Score, this);
d.addField(Board, i18n("Board"), "Board");
d.exec();
*/
}
void ZSameWidget::m_quit() {
// Q_ASSERT(stone);
stone->unmark();
qApp->quit();
// delete this;
}
void ZSameWidget::m_tglboard() {
// kdDebug() << "toggled" << endl;
}
void ZSameWidget::setColors(int ) {
// status->changeItem(i18n("%1 Colors").arg(colors),1);
}
void ZSameWidget::setBoard(int ) {
// status->changeItem(i18n("Board: %1").arg(board, 6), 2);
}
void ZSameWidget::setMarked(int ) {
// status->changeItem(i18n("Marked: %1").arg(m, 6),3);
}
void ZSameWidget::stonesRemoved(int,int) {
// KNotifyClient::event("stones removed",
// i18n("%1 stones removed.").arg(stone->marked()));
}
void ZSameWidget::setScore(int ) {
// status->changeItem(i18n("Score: %1").arg(score, 6),4);
// undo->setEnabled(stone->undoPossible());
// restart->setEnabled(!stone->isOriginalBoard());
}
void ZSameWidget::gameover() {
// kdDebug() << "GameOver" << endl;
if (stone->hasBonus()) {
QMessageBox::information(this,i18n("Game won"),
i18n("<qt>You even removed the last stone, great job! "
"This gave you a score of %1 in total.</qt>").arg(stone->score()));
+ stone->clearBonus();
} else {
QMessageBox::information(this,i18n("Game over"),
i18n("<qt>There are no more removeable stones. "
"You got a score of %1 in total.</qt>").arg(stone->score()));
}
stone->unmark();
}
void ZSameWidget::desktop_widget(int *f)const{
QWidget* wid = QApplication::desktop();
/* width > height landscape mode */
if ( wid->width() > wid->height() ) {
f[0]=15;
f[1]=9;
}
/* normal */
else{
f[0]=12;
f[1]=13;
}
}