knight::Tour Class Reference

Public Member Functions
void	drawBoard (mxvk::VK_Sprite &whiteCell, mxvk::VK_Sprite &redCell, mxvk::VK_Sprite &visitedCell, float scaleX, float scaleY) const
void	drawKnight (mxvk::VK_Sprite &texture, float scaleX, float scaleY) const
int	getMoves () const
bool	isTourOver () const
void	nextMove ()
void	resetTour ()
void	resetTour (int startRow, int startCol)
void	resetTourFromPoint (float x, float y)
	Tour ()

Detailed Description

Definition at line 22 of file knight.cpp.

Constructor & Destructor Documentation

Tour()

knight::Tour::Tour

(

)

Definition at line 265 of file knight.cpp.

               : moves(1), tourOver(false) {
        std::srand(static_cast<unsigned int>(std::time(nullptr)));
        initializeBoard();
        resetTour();
    }

Member Function Documentation

drawBoard()

void knight::Tour::drawBoard	(	mxvk::VK_Sprite &	whiteCell,
		mxvk::VK_Sprite &	redCell,
		mxvk::VK_Sprite &	visitedCell,
		float	scaleX,
		float	scaleY ) const

Definition at line 380 of file knight.cpp.

                                                                                                                                       {
        for (int row = 0; row < BOARD_SIZE; ++row) {
            for (int col = 0; col < BOARD_SIZE; ++col) {
                mxvk::VK_Sprite *cell = nullptr;
                if (board[row][col] == -1) {
                    cell = &visitedCell;
                } else if ((row + col) % 2 == 0) {
                    cell = &whiteCell;
                } else {
                    cell = &redCell;
                }
 
                cell->drawSpriteRect(
                    static_cast<int>(std::lround((START_X + col * CELL_SIZE) * scaleX)),
                    static_cast<int>(std::lround((START_Y + row * CELL_SIZE) * scaleY)),
                    static_cast<int>(std::lround(CELL_DRAW_SIZE * scaleX)),
                    static_cast<int>(std::lround(CELL_DRAW_SIZE * scaleY)));
            }
        }
    }

drawKnight()

void knight::Tour::drawKnight	(	mxvk::VK_Sprite &	texture,
		float	scaleX,
		float	scaleY ) const

Definition at line 401 of file knight.cpp.

                                                                                  {
        texture.drawSpriteRect(
            static_cast<int>(std::lround((START_X + knightPos.col * CELL_SIZE + 5) * scaleX)),
            static_cast<int>(std::lround((START_Y + knightPos.row * CELL_SIZE + 5) * scaleY)),
            static_cast<int>(std::lround(KNIGHT_SIZE * scaleX)),
            static_cast<int>(std::lround(KNIGHT_SIZE * scaleY)));
    }

getMoves()

int knight::Tour::getMoves ( ) const

inlinenodiscard

Definition at line 33 of file knight.cpp.

{ return moves; }

isTourOver()

bool knight::Tour::isTourOver ( ) const

inlinenodiscard

Definition at line 34 of file knight.cpp.

{ return tourOver; }

nextMove()

void knight::Tour::nextMove

(

)

Definition at line 367 of file knight.cpp.

                        {
        if (tourOver || static_cast<std::size_t>(moves) >= moveSequence.size()) {
            return;
        }
 
        const Position nextPosition = moveSequence[static_cast<std::size_t>(moves)];
        board[knightPos.row][knightPos.col] = -1;
        knightPos = nextPosition;
        ++moves;
        board[knightPos.row][knightPos.col] = moves;
        tourOver = static_cast<std::size_t>(moves) == moveSequence.size();
    }

resetTour() [1/2]

void knight::Tour::resetTour

(

)

Definition at line 331 of file knight.cpp.

                         {
        resetTour(std::rand() % BOARD_SIZE, std::rand() % BOARD_SIZE);
    }

resetTour() [2/2]

void knight::Tour::resetTour	(	int	startRow,
		int	startCol )

Definition at line 335 of file knight.cpp.

                                                   {
        if (startRow < 0 || startRow >= BOARD_SIZE || startCol < 0 || startCol >= BOARD_SIZE) {
            return;
        }
 
        clearBoard();
        knightPos = Position(startRow, startCol);
        board[knightPos.row][knightPos.col] = 1;
        moveSequence.clear();
        moveSequence.push_back(knightPos);
        solveKnightsTour(knightPos, 2);
        moves = 1;
        tourOver = false;
    }

resetTourFromPoint()

void knight::Tour::resetTourFromPoint	(	float	x,
		float	y )

Definition at line 350 of file knight.cpp.

                                                  {
        const int localX = static_cast<int>(std::floor(x)) - START_X;
        const int localY = static_cast<int>(std::floor(y)) - START_Y;
        if (localX < 0 || localY < 0) {
            return;
        }
 
        const int col = localX / CELL_SIZE;
        const int row = localY / CELL_SIZE;
        if (row >= BOARD_SIZE || col >= BOARD_SIZE ||
            localX % CELL_SIZE >= CELL_DRAW_SIZE || localY % CELL_SIZE >= CELL_DRAW_SIZE) {
            return;
        }
 
        resetTour(row, col);
    }

---

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

• examples/knight/knight.cpp