StoneField.cpp

Go to the documentation of this file.

/*
 *   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;
}

---