Searching for other pieces in C++ reversi game

Question

I am making a Reversi game in C++ but I am having trouble figuring out how to check for consecutive enemy board pieces once the player places their piece on the board.

The board is an 8x8 2D array with values 0, -1, or 1.

• -1 is a White piece,
• 1 is a black piece and
• 0 is a vacant cell.

The function ApplyMove will simply place the current player's piece on the board and check if there is a run of enemy pieces in any direction. It will then flip all the pieces in that direction.

My function will have these parameters:

void ApplyMove(char board[BOARD_SIZE][BOARD_SIZE], int row, int col, char currentPlayer)

I want the program to use loops to iterate through all 8 possible directions starting from the piece that was placed by the player. How would this be accomplished in the simplest way possible without a bunch of ifs and elses?

Answer 1

One way that strikes me as simple is to use variables xoffset and yoffset which take values 1, 0, -1. Use a for loop on the values of those variables, then a while loop to follow consecutive pieces.

Answer 2

Great question!

I'd suggest you start by thinking about how exactly you determine if a piece should be flipped. In any of your eight directions, you flip any pieces of the opposite color between your piece and the first piece of the same color, and don't flip any if there are any empty spaces before you reach that piece. (Note that this is a pretty handy way to deal with even the case where there are 0 pieces of the opposite color between the two, because you'll flip "all 0" of them.)

There are cool things you can do when you use +/- 1, too -- check the product of values to see whether the colors match (+1) or mismatch (-1), or to flip the token multiply by -1.

Quick mockup of this conceptually, where we're checking the lines of options as well as to make sure we don't leave the board -- I'm using != for not equal, in case that's not familiar to you:

set current_player // +1 or -1
set current_space // say [3, 4]
directions = [[-1, -1], [-1, 0], ...]
for direction in directions:
    spaces_away = 1
    check_space = direction*spaces_away + current_space
    while (check_space has values between 1 and 8 for both x and y) and (check_space != 0)
        if current_player * (direction*spaces_away + current_space) = -1
            spaces_away += 1 // add one so we can check the next space out
            check_space = direction*spaces_away + current_space
        else
            for i from 1 to spaces_away
                flip_space = direction*spaces_away + current_space
                flip_space * -1 // this will change the color

There's some implementation to think about here, mainly the fact that I ignore how you're assigning a -1, 0, or 1 to each of the 64 spaces. Hopefully the pseudocode is clear enough without this.

If the for direction in directions doesn't make sense, take some time to look up what an iterable is. Super useful concept, regardless of what you do here!

Best of luck!