1 files changed, 4 insertions, 0 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
@@ -163,228 +163,232 @@ 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;
 }