summaryrefslogtreecommitdiff
authordrw <drw>2002-03-15 20:33:05 (UTC)
committer drw <drw>2002-03-15 20:33:05 (UTC)
commit20cbfeefd68221f7b6f9dd512c6ff3e9a9484af2 (patch) (side-by-side diff)
tree06e7b467ababb70d10b0c343f5b7881490c20b66
parenteb338502c03edbfc8b9b9f00bd95c0c0d4317003 (diff)
downloadopie-20cbfeefd68221f7b6f9dd512c6ff3e9a9484af2.zip
opie-20cbfeefd68221f7b6f9dd512c6ff3e9a9484af2.tar.gz
opie-20cbfeefd68221f7b6f9dd512c6ff3e9a9484af2.tar.bz2
Fixed segfault and resizing issue for minefield
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/games/minesweep/minefield.cpp410
1 files changed, 256 insertions, 154 deletions
diff --git a/noncore/games/minesweep/minefield.cpp b/noncore/games/minesweep/minefield.cpp
index be2f9a3..eca1a36 100644
--- a/noncore/games/minesweep/minefield.cpp
+++ b/noncore/games/minesweep/minefield.cpp
@@ -1,623 +1,725 @@
/**********************************************************************
** Copyright (C) 2000 Trolltech AS. All rights reserved.
**
** This file is part of Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include "minefield.h"
#include <qpe/config.h>
#include <qpainter.h>
#include <qdrawutil.h>
#include <qpixmap.h>
#include <qimage.h>
#include <qtimer.h>
#include <stdlib.h>
static const char *pix_flag[]={
"13 13 3 1",
"# c #000000",
"x c #ff0000",
". c None",
".............",
".............",
".....#xxxxxx.",
".....#xxxxxx.",
".....#xxxxxx.",
".....#xxxxxx.",
".....#.......",
".....#.......",
".....#.......",
".....#.......",
"...#####.....",
"..#######....",
"............."};
static const char *pix_mine[]={
"13 13 3 1",
"# c #000000",
". c None",
"a c #ffffff",
"......#......",
"......#......",
"..#.#####.#..",
"...#######...",
"..##aa#####..",
"..##aa#####..",
"#############",
"..#########..",
"..#########..",
"...#######...",
"..#.#####.#..",
"......#......",
"......#......"};
-class Mine : public QTableItem
+
+static const int maxGrid = 28;
+static const int minGrid = 9;
+
+
+
+class Mine : public Qt
{
public:
enum MineState {
Hidden = 0,
Empty,
Mined,
Flagged,
#ifdef MARK_UNSURE
Unsure,
#endif
Exploded,
Wrong
};
- Mine( QTable* );
- void paint( QPainter * p, const QColorGroup & cg, const QRect & cr, bool selected );
- EditType editType() const { return Never; }
- QSize sizeHint() const { return QSize( 12, 12 ); }
+ Mine( MineField* );
+ void paint( QPainter * p, const QColorGroup & cg, const QRect & cr );
+
+ QSize sizeHint() const { return QSize( maxGrid, maxGrid ); }
void activate( bool sure = TRUE );
void setHint( int );
void setState( MineState );
MineState state() const { return st; }
bool isMined() const { return mined; }
void setMined( bool m ) { mined = m; }
static void paletteChange();
private:
bool mined;
int hint;
MineState st;
-
+ MineField *field;
+
static QPixmap* knownField;
static QPixmap* unknownField;
static QPixmap* flag_pix;
static QPixmap* mine_pix;
};
QPixmap* Mine::knownField = 0;
QPixmap* Mine::unknownField = 0;
QPixmap* Mine::flag_pix = 0;
QPixmap* Mine::mine_pix = 0;
-Mine::Mine( QTable *t )
-: QTableItem( t, Never, QString::null )
+Mine::Mine( MineField *f )
{
mined = FALSE;
st = Hidden;
hint = 0;
+ field = f;
}
void Mine::activate( bool sure )
{
if ( !sure ) {
switch ( st ) {
case Hidden:
setState( Flagged );
break;
case Flagged:
#ifdef MARK_UNSURE
setState( Unsure );
break;
case Unsure:
#endif
setState( Hidden );
default:
break;
}
} else if ( st == Flagged ) {
return;
} else {
if ( mined ) {
setState( Exploded );
} else {
setState( Empty );
}
}
}
void Mine::setState( MineState s )
{
st = s;
}
void Mine::setHint( int h )
{
hint = h;
}
void Mine::paletteChange()
{
delete knownField;
knownField = 0;
delete unknownField;
unknownField = 0;
delete mine_pix;
mine_pix = 0;
delete flag_pix;
flag_pix = 0;
}
-void Mine::paint( QPainter* p, const QColorGroup &cg, const QRect& cr, bool )
+void Mine::paint( QPainter* p, const QColorGroup &cg, const QRect& cr )
{
+ int x = cr.x();
+ int y = cr.y();
if ( !knownField ) {
knownField = new QPixmap( cr.width(), cr.height() );
QPainter pp( knownField );
QBrush br( cg.button().dark(115) );
- qDrawWinButton( &pp, QRect(0,0,cr.width(), cr.height())/*cr*/, cg, TRUE, &br );
+ qDrawWinButton( &pp, cr, cg, TRUE, &br );
}
const int pmmarg=cr.width()/5;
if ( !unknownField ) {
unknownField = new QPixmap( cr.width(), cr.height() );
QPainter pp( unknownField );
QBrush br( cg.button() );
- qDrawWinButton( &pp, QRect(0,0,cr.width(), cr.height())/*cr*/, cg, FALSE, &br );
+ qDrawWinButton( &pp, cr, cg, FALSE, &br );
}
if ( !flag_pix ) {
flag_pix = new QPixmap( cr.width()-pmmarg*2, cr.height()-pmmarg*2 );
flag_pix->convertFromImage( QImage(pix_flag).smoothScale(cr.width()-pmmarg*2, cr.height()-pmmarg*2) );
}
if ( !mine_pix ) {
mine_pix = new QPixmap( cr.width()-pmmarg*2, cr.height()-pmmarg*2 );
mine_pix->convertFromImage( QImage(pix_mine).smoothScale(cr.width()-pmmarg*2, cr.height()-pmmarg*2) );
}
p->save();
switch(st) {
case Hidden:
- p->drawPixmap( 0, 0, *unknownField );
+ p->drawPixmap( x, y, *unknownField );
break;
case Empty:
- p->drawPixmap( 0, 0, *knownField );
+ p->drawPixmap( x, y, *knownField );
if ( hint > 0 ) {
switch( hint ) {
case 1:
p->setPen( blue );
break;
case 2:
- p->setPen( green );
+ p->setPen( green.dark() );
+ break;
case 3:
p->setPen( red );
break;
- default:
+ case 4:
+ p->setPen( darkYellow.dark() );
+ break;
+ case 5:
p->setPen( darkMagenta );
break;
+ case 6:
+ p->setPen( darkRed );
+ break;
+ default:
+ p->setPen( black );
+ break;
}
- p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, QString().setNum( hint ) );
+ p->drawText( cr, AlignHCenter | AlignVCenter, QString::number( hint ) );
}
break;
case Mined:
- p->drawPixmap( 0, 0, *knownField );
- p->drawPixmap( pmmarg, pmmarg, *mine_pix );
+ p->drawPixmap( x, y, *knownField );
+ p->drawPixmap( x+pmmarg, y+pmmarg, *mine_pix );
break;
case Exploded:
- p->drawPixmap( 0, 0, *knownField );
- p->drawPixmap( pmmarg, pmmarg, *mine_pix );
+ p->drawPixmap( x, y, *knownField );
+ p->drawPixmap( x+pmmarg, y+pmmarg, *mine_pix );
p->setPen( red );
- p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, "X" );
+ p->drawText( cr, AlignHCenter | AlignVCenter, "X" );
break;
case Flagged:
- p->drawPixmap( 0, 0, *unknownField );
- p->drawPixmap( pmmarg, pmmarg, *flag_pix );
+ p->drawPixmap( x, y, *unknownField );
+ p->drawPixmap( x+pmmarg, y+pmmarg, *flag_pix );
break;
#ifdef MARK_UNSURE
case Unsure:
- p->drawPixmap( 0, 0, *unknownField );
- p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, "?" );
+ p->drawPixmap( x, y, *unknownField );
+ p->drawText( cr, AlignHCenter | AlignVCenter, "?" );
break;
#endif
case Wrong:
- p->drawPixmap( 0, 0, *unknownField );
- p->drawPixmap( pmmarg, pmmarg, *flag_pix );
+ p->drawPixmap( x, y, *unknownField );
+ p->drawPixmap( x+pmmarg, y+pmmarg, *flag_pix );
p->setPen( red );
- p->drawText( QRect( 0, 0, cr.width(), cr.height() ), AlignHCenter | AlignVCenter, "X" );
+ p->drawText( cr, AlignHCenter | AlignVCenter, "X" );
break;
}
p->restore();
}
/*
MineField implementation
*/
MineField::MineField( QWidget* parent, const char* name )
-: QTable( parent, name )
+: QScrollView( parent, name )
{
setState( GameOver );
- setShowGrid( FALSE );
- horizontalHeader()->hide();
- verticalHeader()->hide();
- setTopMargin( 0 );
- setLeftMargin( 0 );
setSizePolicy( QSizePolicy( QSizePolicy::Maximum, QSizePolicy::Maximum ) );
-
- setSelectionMode( QTable::NoSelection );
- setFocusPolicy( QWidget::NoFocus );
-
- setCurrentCell( -1, -1 );
- connect( this, SIGNAL( pressed( int, int, int, const QPoint& ) ), this, SLOT( cellPressed( int, int ) ) );
- connect( this, SIGNAL( clicked( int, int, int, const QPoint& ) ), this, SLOT( cellClicked( int, int ) ) );
+ setFocusPolicy( QWidget::NoFocus );
holdTimer = new QTimer( this );
connect( holdTimer, SIGNAL( timeout() ), this, SLOT( held() ) );
flagAction = NoAction;
ignoreClick = FALSE;
- currRow = currCol = 0;
+ currRow = currCol = -1;
minecount=0;
mineguess=0;
nonminecount=0;
+ cellSize = -1;
+ mines = 0;
}
MineField::~MineField()
{
+ int i;
+ if ( mines )
+ {
+ for ( i = 0; i < numCols*numRows; i++ )
+ {
+ delete mines[i];
+ }
+ delete[] mines;
+ }
}
void MineField::setState( State st )
{
stat = st;
}
-
void MineField::setup( int level )
{
lev = level;
setState( Waiting );
- viewport()->setUpdatesEnabled( FALSE );
-
- int cellsize;
-
- int x;
- int y;
- for ( x = 0; x < numCols(); x++ )
- for ( y = 0; y < numRows(); y++ )
- clearCell( y, x );
+ //viewport()->setUpdatesEnabled( FALSE );
+
+ int i;
+ if ( mines )
+ {
+ for ( i = 0; i < numCols*numRows; i++ )
+ {
+ delete mines[i];
+ }
+ delete[] mines;
+ }
switch( lev ) {
case 1:
- setNumRows( 9 );
- setNumCols( 9 );
+ numRows = 9 ;
+ numCols = 9 ;
minecount = 12;
- cellsize = 21;
break;
case 2:
- setNumRows( 16 );
- setNumCols( 16 );
+ numRows = 16;
+ numCols = 16;
minecount = 45;
- cellsize = 14;
break;
case 3:
- setNumRows( 18 );
- setNumCols( 18 );
+ numCols = 18;
+ numRows = 18;
minecount = 66 ;
- cellsize = 12;
break;
}
- nonminecount = numRows()*numCols() - minecount;
+ mines = new (Mine*)[numRows*numCols];
+ for ( i = 0; i < numCols*numRows; i++ )
+ mines[i] = new Mine( this );
+
+
+ nonminecount = numRows*numCols - minecount;
mineguess = minecount;
emit mineCount( mineguess );
Mine::paletteChange();
- for ( y = 0; y < numRows(); y++ )
- setRowHeight( y, cellsize );
- for ( x = 0; x < numCols(); x++ )
- setColumnWidth( x, cellsize );
- for ( x = 0; x < numCols(); x++ )
- for ( y = 0; y < numRows(); y++ )
- setItem( y, x, new Mine( this ) );
-
+ if ( availableRect.isValid() )
+ setCellSize(findCellSize());
+ // viewport()->setUpdatesEnabled( TRUE );
+ //viewport()->repaint( TRUE );
+ updateContents( 0, 0, numCols*cellSize, numRows*cellSize );
updateGeometry();
- viewport()->setUpdatesEnabled( TRUE );
- viewport()->repaint( TRUE );
+}
+
+void MineField::drawContents( QPainter * p, int clipx, int clipy, int clipw, int cliph )
+{
+ int c1 = clipx / cellSize;
+ int c2 = ( clipx + clipw - 1 ) / cellSize;
+ int r1 = clipy / cellSize;
+ int r2 = ( clipy + cliph - 1 ) / cellSize;
+
+ for ( int c = c1; c <= c2 ; c++ ) {
+ for ( int r = r1; r <= r2 ; r++ ) {
+ int x = c * cellSize;
+ int y = r * cellSize;
+ Mine *m = mine( r, c );
+ if ( m )
+ m->paint( p, colorGroup(), QRect(x, y, cellSize, cellSize ) );
+ }
+ }
+}
+
+
+// Chicken and egg problem: We need to know how big the parent is
+// before we can decide how big to make the table.
+
+void MineField::setAvailableRect( const QRect &r )
+{
+ availableRect = r;
+ int newCellSize = findCellSize();
+ if ( newCellSize != cellSize ) {
+ viewport()->setUpdatesEnabled( FALSE );
+ setCellSize( newCellSize );
+ viewport()->setUpdatesEnabled( TRUE );
+ viewport()->repaint( TRUE );
+ }
+}
+
+int MineField::findCellSize()
+{
+ int w = availableRect.width() - 1;
+ int h = availableRect.height() - 1;
+ int cellsize;
+
+ cellsize = QMIN( w/numCols, h/numRows );
+ cellsize = QMIN( QMAX( cellsize, minGrid ), maxGrid );
+ return cellsize;
+}
+
+
+void MineField::setCellSize( int cellsize )
+{
+ cellSize = cellsize;
+
+ int w = availableRect.width();
+ int h = availableRect.height();
+
+ int w2 = cellsize*numCols;
+ int h2 = cellsize*numRows;
+
+ resizeContents( w2, h2 );
+
+ int b = 5;
+
+ setGeometry( availableRect.x() + (w-w2)/2, availableRect.y() + (h-h2)/2,
+ w2+b, h2+b );
+// QMIN(w,w2+b), QMIN(h,h2+b) );
}
void MineField::placeMines()
{
int mines = minecount;
while ( mines ) {
- int col = int((double(rand()) / double(RAND_MAX)) * numCols());
- int row = int((double(rand()) / double(RAND_MAX)) * numRows());
+ int col = int((double(rand()) / double(RAND_MAX)) * numCols);
+ int row = int((double(rand()) / double(RAND_MAX)) * numRows);
- Mine* mine = (Mine*)item( row, col );
+ Mine* m = mine( row, col );
- if ( mine && !mine->isMined() && mine->state() == Mine::Hidden ) {
- mine->setMined( TRUE );
+ if ( m && !m->isMined() && m->state() == Mine::Hidden ) {
+ m->setMined( TRUE );
mines--;
}
}
}
-void MineField::paintFocus( QPainter*, const QRect& )
+
+void MineField::updateCell( int r, int c )
{
+ updateContents( c*cellSize, r*cellSize, cellSize, cellSize );
}
-void MineField::viewportMousePressEvent( QMouseEvent* e )
+
+void MineField::contentsMousePressEvent( QMouseEvent* e )
{
- QTable::viewportMousePressEvent( e );
+ int c = e->pos().x() / cellSize;
+ int r = e->pos().y() / cellSize;
+ if ( onBoard( r, c ) )
+ cellPressed( r, c );
+ else
+ currCol = currRow = -1;
}
-void MineField::viewportMouseReleaseEvent( QMouseEvent* e )
+void MineField::contentsMouseReleaseEvent( QMouseEvent* e )
{
- QTable::viewportMouseReleaseEvent( e );
+ int c = e->pos().x() / cellSize;
+ int r = e->pos().y() / cellSize;
+ if ( onBoard( r, c ) && c == currCol && r == currRow )
+ cellClicked( r, c );
+
+
if ( flagAction == FlagNext ) {
flagAction = NoAction;
}
}
+
+
+/*
+ state == Waiting means no "hold"
+
+
+*/
+void MineField::cellPressed( int row, int col )
+{
+ if ( state() == GameOver )
+ return;
+ currRow = row;
+ currCol = col;
+ if ( state() == Playing )
+ holdTimer->start( 150, TRUE );
+}
+
+void MineField::held()
+{
+ flagAction = FlagNext;
+ updateMine( currRow, currCol );
+ ignoreClick = TRUE;
+}
+
+
+
+
void MineField::keyPressEvent( QKeyEvent* e )
{
#if defined(Q_WS_QWS) || defined(_WS_QWS_)
flagAction = ( e->key() == Key_Up ) ? FlagOn : NoAction;
#else
flagAction = ( ( e->state() & ShiftButton ) == ShiftButton ) ? FlagOn : NoAction;
#endif
}
void MineField::keyReleaseEvent( QKeyEvent* )
{
flagAction = NoAction;
}
int MineField::getHint( int row, int col )
{
int hint = 0;
for ( int c = col-1; c <= col+1; c++ )
for ( int r = row-1; r <= row+1; r++ ) {
- Mine* mine = (Mine*)item( r, c );
- if ( mine && mine->isMined() )
+ Mine* m = mine( r, c );
+ if ( m && m->isMined() )
hint++;
}
return hint;
}
-void MineField::setHint( Mine* mine )
+void MineField::setHint( int row, int col )
{
- if ( !mine )
+ Mine *m = mine( row, col );
+ if ( !m )
return;
- int row = mine->row();
- int col = mine->col();
int hint = getHint( row, col );
if ( !hint ) {
for ( int c = col-1; c <= col+1; c++ )
for ( int r = row-1; r <= row+1; r++ ) {
- Mine* mine = (Mine*)item( r, c );
- if ( mine && mine->state() == Mine::Hidden ) {
- mine->activate( TRUE );
+ Mine* m = mine( r, c );
+ if ( m && m->state() == Mine::Hidden ) {
+ m->activate( TRUE );
nonminecount--;
- setHint( mine );
+ setHint( r, c );
updateCell( r, c );
}
}
}
- mine->setHint( hint );
+ m->setHint( hint );
updateCell( row, col );
}
/*
- state == Waiting means no "hold"
-
-
-*/
-void MineField::cellPressed( int row, int col )
-{
- if ( state() == GameOver )
- return;
- currRow = row;
- currCol = col;
- if ( state() == Playing )
- holdTimer->start( 150, TRUE );
-}
-
-void MineField::held()
-{
- flagAction = FlagNext;
- updateMine( currRow, currCol );
- ignoreClick = TRUE;
-}
-
-/*
Only place mines after first click, since it is pointless to
kill the player before the game has started.
*/
void MineField::cellClicked( int row, int col )
{
if ( state() == GameOver )
return;
if ( state() == Waiting ) {
- Mine* mine = (Mine*)item( row, col );
- if ( !mine )
+ Mine* m = mine( row, col );
+ if ( !m )
return;
- mine->setState( Mine::Empty );
+ m->setState( Mine::Empty );
nonminecount--;
placeMines();
setState( Playing );
emit gameStarted();
updateMine( row, col );
} else { // state() == Playing
holdTimer->stop();
if ( ignoreClick )
ignoreClick = FALSE;
else
updateMine( row, col );
}
}
void MineField::updateMine( int row, int col )
{
- Mine* mine = (Mine*)item( row, col );
- if ( !mine )
+ Mine* m = mine( row, col );
+ if ( !m )
return;
- bool wasFlagged = mine->state() == Mine::Flagged;
- bool wasEmpty = mine->state() == Mine::Empty;
+ bool wasFlagged = m->state() == Mine::Flagged;
+ bool wasEmpty = m->state() == Mine::Empty;
- mine->activate( flagAction == NoAction );
+ m->activate( flagAction == NoAction );
- if ( mine->state() == Mine::Exploded ) {
+ if ( m->state() == Mine::Exploded ) {
emit gameOver( FALSE );
setState( GameOver );
return;
- } else if ( mine->state() == Mine::Empty ) {
- setHint( mine );
+ } else if ( m->state() == Mine::Empty ) {
+ setHint( row, col );
if ( !wasEmpty )
nonminecount--;
}
if ( flagAction != NoAction ) {
- if ( mine->state() == Mine::Flagged ) {
+ if ( m->state() == Mine::Flagged ) {
--mineguess;
emit mineCount( mineguess );
- if ( mine->isMined() )
+ if ( m->isMined() )
--minecount;
} else if ( wasFlagged ) {
++mineguess;
emit mineCount( mineguess );
- if ( mine->isMined() )
+ if ( m->isMined() )
++minecount;
}
}
updateCell( row, col );
if ( !minecount && !mineguess || !nonminecount ) {
emit gameOver( TRUE );
setState( GameOver );
}
}
void MineField::showMines()
{
- for ( int c = 0; c < numCols(); c++ )
- for ( int r = 0; r < numRows(); r++ ) {
- Mine* mine = (Mine*)item( r, c );
- if ( !mine )
+ for ( int c = 0; c < numCols; c++ )
+ for ( int r = 0; r < numRows; r++ ) {
+ Mine* m = mine( r, c );
+ if ( !m )
continue;
- if ( mine->isMined() && mine->state() == Mine::Hidden )
- mine->setState( Mine::Mined );
- if ( !mine->isMined() && mine->state() == Mine::Flagged )
- mine->setState( Mine::Wrong );
+ if ( m->isMined() && m->state() == Mine::Hidden )
+ m->setState( Mine::Mined );
+ if ( !m->isMined() && m->state() == Mine::Flagged )
+ m->setState( Mine::Wrong );
updateCell( r, c );
}
}
void MineField::paletteChange( const QPalette &o )
{
Mine::paletteChange();
- QTable::paletteChange( o );
+ QScrollView::paletteChange( o );
}
void MineField::writeConfig(Config& cfg) const
{
cfg.setGroup("Field");
cfg.writeEntry("Level",lev);
QString grid="";
if ( stat == Playing ) {
- for ( int x = 0; x < numCols(); x++ )
- for ( int y = 0; y < numRows(); y++ ) {
+ for ( int x = 0; x < numCols; x++ )
+ for ( int y = 0; y < numRows; y++ ) {
char code='A'+(x*17+y*101)%21; // Reduce the urge to cheat
- Mine* mine = (Mine*)item( y, x );
- int st = (int)mine->state(); if ( mine->isMined() ) st+=5;
+ const Mine* m = mine( y, x );
+ int st = (int)m->state(); if ( m->isMined() ) st+=5;
grid += code + st;
}
}
cfg.writeEntry("Grid",grid);
}
void MineField::readConfig(Config& cfg)
{
cfg.setGroup("Field");
lev = cfg.readNumEntry("Level",1);
setup(lev);
flagAction = NoAction;
ignoreClick = FALSE;
currRow = currCol = 0;
QString grid = cfg.readEntry("Grid");
if ( !grid.isEmpty() ) {
int i=0;
minecount=0;
mineguess=0;
- for ( int x = 0; x < numCols(); x++ ) {
- for ( int y = 0; y < numRows(); y++ ) {
+ for ( int x = 0; x < numCols; x++ ) {
+ for ( int y = 0; y < numRows; y++ ) {
char code='A'+(x*17+y*101)%21; // Reduce the urge to cheat
int st = (char)(QChar)grid[i++]-code;
- Mine* mine = (Mine*)item( y, x );
+ Mine* m = mine( y, x );
if ( st >= 5 ) {
st-=5;
- mine->setMined(TRUE);
+ m->setMined(TRUE);
minecount++;
mineguess++;
}
- mine->setState((Mine::MineState)st);
- switch ( mine->state() ) {
+ m->setState((Mine::MineState)st);
+ switch ( m->state() ) {
case Mine::Flagged:
- if (mine->isMined())
+ if (m->isMined())
minecount--;
mineguess--;
break;
case Mine::Empty:
--nonminecount;
+ break;
+ default:
+ break;
}
}
}
- for ( int x = 0; x < numCols(); x++ ) {
- for ( int y = 0; y < numRows(); y++ ) {
- Mine* mine = (Mine*)item( y, x );
- if ( mine->state() == Mine::Empty )
- mine->setHint(getHint(y,x));
+ for ( int x = 0; x < numCols; x++ ) {
+ for ( int y = 0; y < numRows; y++ ) {
+ Mine* m = mine( y, x );
+ if ( m->state() == Mine::Empty )
+ m->setHint(getHint(y,x));
}
}
}
setState( Playing );
emit mineCount( mineguess );
}