Board Class Reference

Board of game. More...

#include <Board.hpp>

Public Member Functions
	Board ()=default
	Construct a new Board object (default constructor) More...
	~Board ()
	Destroy the Board object. More...
void	set (unsigned int w, unsigned int h, unsigned int m)
	Set values on the board. More...
void	restart ()
	Restart the board. More...
bool	uncover (const Vector2D &click)
	Uncover the choosen field. More...
bool	action (const Vector2D &click)
	Do second action on selected field. More...
void	debug () const
	Display board on the console to debuging. More...
short int	noFlaggedMines () const
	Number of no flagged mines on the board. More...
int	w () const
	Width of board. More...
int	h () const
	Height of board. More...
bool	created () const
	Is array created? More...
bool	inside (const Vector2D &pos) const
	Is filel inside the board. More...
bool	hint (Vector2D *&pos) const
	Find a hint for player with AI. More...
const Field &	operator() (const Vector2D &vec) const
	Value of field. More...

Private Member Functions
Field &	operator() (const Vector2D &vec)
	Value of field. More...
void	uncoverAll ()
	Uncover all fields on the board. More...
void	flagAll ()
	Set flag on the all of mines fields. More...
void	alloc ()
	Create a array of board. More...
void	free ()
	Free memory if board array exist. More...
void	randMines (const Vector2D &click)
	Rand mines position on the board. More...
void	calcFields ()
	Calculate values of field after rand mines position. More...

Private Attributes
Vector2D	size {0,0}
	Size od board. More...
Field **	board {NULL}
	Array of fields on the board. Coordinates: Board[ x ][ y ]. More...
short int	mines_init
	Number of mines in beginning of the game. More...
short int	mines
	Number of no flagged mines. More...
short unsigned int	covered
	Number of covered fields. More...

Static Private Attributes
static const Vector2D	AROUND [8]
	Vectors of around coordinates. More...

Detailed Description

Board of game.

Constructor & Destructor Documentation

Board()

Board::Board ( )

default

Construct a new Board object (default constructor)

~Board()

Board::~Board

(

)

Destroy the Board object.

             {
    this->free();
}

Member Function Documentation

set()

void Board::set	(	unsigned int	w,
		unsigned int	h,
		unsigned int	m
	)

Set values on the board.

Parameters

w	- width
h	- height
m	- number of minse

Postcondition

Modifly size and mines

• Check exceptions
• Set values

                                                               {
    if( m < MIN_MINES )         throw ErrInput("Too least mines!");
    if( m > size.area() - 9 )   throw ErrInput("Too much mines!");
 
    if( size.area() > MIN_AREA ) throw ErrInput("Too little area!");
 
    this->mines = m;
    this->mines_init = m;
    this->size = Vector2D( w, h );
    this->covered = size.area() - m;
}

restart()

void Board::restart

(

)

Restart the board.

Postcondition

• Free board
• Restart covered value

                   {
    this->free();
 
    this->mines = this->mines_init;
    covered = size.area() - this->mines_init;
}

uncover()

bool Board::uncover

(

const Vector2D &

click

)

Uncover the choosen field.

Parameters

click

- position of the field

Return values

true	- Done a click
false	- click unavaliable

• Nothing do when click on the uncovered
• Uncover around if click on the empty field
• Lose the game when uncover a mine
• Win the game when uncover every right fields
• Create, randMines and uncover the field (recursive!)

                                          {
 
    if( this->created() ){
 
        if( (*this)(click).covered() ){
 
            (*this)(click).uncover();
            --this->covered;
 
            if( (*this)(click).empty() ){
                for(uint8_t i=0; i<8; ++i ){
                    if( this->inside( click + Board::AROUND[i] ) )
                        this->uncover( click + Board::AROUND[i] );  //recursive!
                }
            }
            else
                if( (*this)(click).mine() ){
                    this->uncoverAll();
                    throw EndGame("Boooom!");
                }
 
            if( this->covered == 0 ){
                this->flagAll();
                this->mines = 0;
                throw EndGame("Win!");
            }
        }
        else return false;      // move unavaliable
    }
    else {
        alloc();
        randMines( click );
        calcFields();
        this->uncover( click );
 
        /* Test fragment <---
        for( int i=0; i<10; ++i ){
            (*this)(Vector2D(1,i)).val( i );
            (*this)(Vector2D(1,i)).uncover();
        }
        (*this)(Vector2D(3,3)).flag();
        // ---> */
    }
 
    return true;
}

action()

bool Board::action

(

const Vector2D &

click

)

Do second action on selected field.

Parameters

click

- position of the field

Return values

true	- Done a move
false	- move unavaliable

• If field is flagged, unflag.
• If field is covered, flag.
• If field is uncover, uncover around (if it's possible).

                                         {
 
    if( (*this)(click).flagged() ){
        (*this)(click).unflag();
        ++this->mines;
    }
    else {
        if( (*this)(click).covered() ){
            (*this)(click).flag();
            --this->mines;
        }
        else{
            // uncover around
            uint8_t nflags = 0;         // number of flags around
 
            for(uint8_t i=0; i<8; ++i )
                if( this->inside( click + Board::AROUND[i] ) )
                    if( (*this)(click + Board::AROUND[i] ).flagged() )
                        ++nflags;
 
            // uncover around is possible
            if( nflags == (*this)(click).val() ){
                for(uint8_t i=0; i<8; ++i )
                    if( this->inside( click + Board::AROUND[i] ) )
                        this->uncover( click + Board::AROUND[i] );
            }
            else
                return false;   //action is unavaliable!
        }
    }
 
    return true;
}

debug()

void Board::debug

(

)

const

Display board on the console to debuging.

                        {
    cout << "  ";
    for(int x=0;x<size.x;++x) cout << "|" << setw(4) << x << " ";
    cout << endl;
    for(int y=0;y<size.y;++y){
        cout << y << " ";
        for(int x=0;x<size.x;++x)
            cout << (*this)(Vector2D(x,y));
        cout << endl;
    }
}

noFlaggedMines()

short int Board::noFlaggedMines ( ) const

inline

Number of no flagged mines on the board.

Returns

short int - number of no flagged mines = mines_init - flag

    { return mines; }

w()

int Board::w ( ) const

inline

Width of board.

Returns

unsigned int - width

    { return this->size.x; }

h()

int Board::h ( ) const

inline

Height of board.

Returns

unsigned int - width

    { return this->size.y; }

created()

bool Board::created ( ) const

inline

Is array created?

Returns

true - yes

false - no

    { return this->board != NULL; }

inside()

bool Board::inside ( const Vector2D &  pos ) const

inline

Is filel inside the board.

Parameters

pos	- position of field

Returns

true - yes

false - no

    { return ( pos.x >= 0 && pos.x < size.x ) && ( pos.y >= 0 && pos.y < size.y ); }

hint()

bool Board::hint

(

Vector2D *&

pos

)

const

Find a hint for player with AI.

Parameters

[out]

pos

- Position of hint move

Returns

true - is hint

false - isn't hint

• Claer hint position
• Find probably mines position
• Find safe position

                                       {
 
    if( pos != NULL ){
        delete pos;
        pos = NULL;
    }
 
    Vector2D vec, next;
    Field value;
    uint8_t probably_mine, hidden;
    //** Bool array of probable position mines
    bool *mines_arr = new bool[ size.x * size.y ];
 
    // Set false on the whole mines_arr array
    for( short int i=0; i < (size.x * size.y); ++i )
        mines_arr[i] = false;
 
    for( next.x = 0; next.x < size.x; ++next.x )
        for( next.y = 0; next.y < size.y; ++next.y ){
 
            if( (*this)( next ).uncovered() ){              // uncovered
                if( (*this)( next ).empty() ) continue;     // and not empty
 
                // count all of uncovered fields around
                hidden = 0;
                for( uint8_t i=0; i<8; ++i ){
                    vec = next + Board::AROUND[i];
 
                    if( this->inside( vec ) )               // inside the board
                        if( (*this)( vec ).hidden() )       // count hidden
                            ++hidden;
                }
 
                // if hidden == value then all of them is probably mines
                // hidden = covered + flagged
                if( hidden == (*this)( next ).val() )
                    for( uint8_t i=0; i<8; ++i ){
                        vec = next + Board::AROUND[i];
 
                        if( this->inside( vec ) )
                            if( (*this)( vec ).hidden() )
                                mines_arr[ vec.y*size.x + vec.x ] = true;
                    }
            }
        }
 
    /* test: display mines_arr
    for( next.y = 0; next.y < size.y; ++next.y ){
        for( next.x = 0; next.x < size.x; ++next.x )
            std::cout << mines_arr[ next.y*size.x + next.x ] << " ";
        std::cout << std::endl;
    } // test end */
 
    for( next.x = 0; next.x < size.x; ++next.x )
        for( next.y = 0; next.y < size.y; ++next.y ){
 
            if( (*this)( next ).uncovered() ){              // uncovered
                if( (*this)( next ).empty() ) continue;     // and not empty
 
                // count all flag around
                probably_mine = 0;
                for( uint8_t i=0; i<8; ++i ){
                    vec = next + Board::AROUND[i];
 
                    if( this->inside( vec ) )            // inside
                        if( mines_arr[ vec.y*size.x + vec.x ] )
                            ++probably_mine;
                }
 
                // if probably_mine == value then covered and ! mines_arr[] fields are safe
                if( probably_mine == (*this)( next ).val() )
                    for( uint8_t i=0; i<8; ++i ){
                        vec = next + Board::AROUND[i];
 
                        if( this->inside( vec ) )
                            if( ! mines_arr[ vec.y*size.x + vec.x ] && (*this)( vec ).covered() ){
                                // found the hint
                                pos = new Vector2D(vec);
                                delete[] mines_arr;
                                return true;
                            }
                    }
            }
        }
 
    // end of fun.
    delete[] mines_arr;
    return false;
}

operator()() [1/2]

const Field& Board::operator() ( const Vector2D &  vec ) const

inline

Value of field.

Without checking a correct of position!

Warning

Method don't check, is field exist!

Parameters

vec	- position on the board

Returns

Field& - field const

    { return board[ vec.x ][ vec.y ]; }

operator()() [2/2]

Field& Board::operator() ( const Vector2D &  vec )

inlineprivate

Value of field.

Without checking a correct of position!

Warning

Method don't check, is field exist!

Parameters

vec	- position on the board

Returns

Field& - field to edit

    { return board[ vec.x ][ vec.y ]; }

uncoverAll()

void Board::uncoverAll ( )

private

Uncover all fields on the board.

                      {
    Vector2D pos;
    for(; pos.x < size.x; ++pos.x )
        for( pos.y=0; pos.y < size.y; ++pos.y )
            (*this)(pos).uncover();
}

flagAll()

void Board::flagAll ( )

private

Set flag on the all of mines fields.

                   {
    Vector2D pos;
    for(; pos.x < size.x; ++pos.x )
        for( pos.y=0; pos.y < size.y; ++pos.y )
            if( (*this)(pos).mine() ) (*this)(pos).flag();
}

alloc()

void Board::alloc ( )

private

Create a array of board.

Default value of field is: empty, covered.

Postcondition

Modify only board.

Parameters

size_

- Vector2D of new boards sizes.

Create new board

                 {
    if( size.x < 1 || size.y < 1 ) throw ErrSys("ALLOC 001");
 
    this->board = new Field*[ size.x ];
    if( this->board == NULL ) throw ErrAlloc();
 
    for( int i=0; i<size.x; ++i ){
        this->board[i] = new Field[ size.y ];
        if( this->board[i] == NULL ) throw ErrAlloc();
    }
}

free()

void Board::free ( )

private

Free memory if board array exist.

                {
    if( this->board != NULL ){
        for( short int i=0; i<size.y; ++i )
            delete[] this->board[i];
 
        delete[] this->board;
    }
    this->board = NULL;
}

randMines()

void Board::randMines ( const Vector2D &  click )

private

Rand mines position on the board.

Exceptions

Possible

exceptions: Too much mines! Maximum number of mines is area of board - 9 (first click is on the empty field!) Too least mines! Minumum number of mines is const in Const.hpp.

Parameters

click

- where was the first click

Rand a position of mines on the board.

                                            {
    Vector2D pos;
    short unsigned int num_mines = mines;
    unsigned max_att = MAX_ATTEMPTS;
 
    std::default_random_engine generator( time(NULL) );
    std::uniform_int_distribution<int> distribution_x( 0, size.x-1 );
    std::uniform_int_distribution<int> distribution_y( 0, size.y-1 );
 
    while( num_mines > 0 ){
        pos.x = distribution_x(generator);
        pos.y = distribution_y(generator);
 
        if( (*this)( pos ).mine() == false && ! click.adj( pos ) ){
            (*this)( pos ) = FieldCode::Mine;
            --num_mines;
        }
        else {
            if( 0 == --max_att )
                throw ErrSys("Too much attempts to rand location of mines.");
        }
    }
}

calcFields()

void Board::calcFields ( )

private

Calculate values of field after rand mines position.

                      {
 
    uint8_t count;                          // counter of mines around
    Vector2D pos, around;
 
    for( pos.x=0; pos.x < size.x; ++pos.x )
        for( pos.y=0; pos.y < size.y; ++pos.y ){
 
            if( ! (*this)(pos).mine() ){
                count = 0;                      // clear counter
 
                for(uint8_t i=0; i<8; ++i ){    // check around
                    around = pos + Board::AROUND[i];
                    if( this->inside( around ) )
                        if( (*this)(around).mine() ) ++count;
                }
 
                (*this)(pos).val( count );      // set values
            }
        }
}

Member Data Documentation

size

Vector2D Board::size {0,0}

private

Size od board.

board

Field** Board::board {NULL}

private

Array of fields on the board. Coordinates: Board[ x ][ y ].

mines_init

short int Board::mines_init

private

Number of mines in beginning of the game.

mines

short int Board::mines

private

Number of no flagged mines.

covered

short unsigned int Board::covered

private

Number of covered fields.

AROUND

const Vector2D Board::AROUND

staticprivate

Initial value:

= {               
    {-1,-1},{0,-1},{1,-1},
    {-1,0},{1,0},
    {-1,1},{0,1},{1,1}
}

Vectors of around coordinates.

---

The documentation for this class was generated from the following files:

• Board.hpp
• Board.cpp