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
@@ -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;
     }
 }