Fix #1450 to clear the 'bonus' for removing every stone in the game

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
@@ -99,292 +99,296 @@ StoneField::newGame(unsigned int board,int colors) {
 
 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;
     }
 }