Reversi Game Logic Help

Sigchi4life
Category:
Computer Science
Price: $5 USD

Question description

I am having trouble with functions in my reversi logic code. The function is the isLegalMove I am asked to "Return a Boolean indicating if the current player can place their chip in the square at position (row, col). Both row and col must be valid indices​." So I came up with my code below, however a move I make in the game says Error: not a legal move. And I need help with my isOver function which I tried below.

Attached is the instruction sheet if needed.proj2.pdf 

 Please help!

from ezarrays import Array2D

# Values representing the color of the chips on the board.

EMPTY = 0

BLACK = 1

WHITE = 2

class ReversiGameLogic :

  # Creates an instance of Reversi game logic with the board correctly

  # initialized and the current player set to black.

  def __init__(self) :

     # Use a 2-D array to represent the board.

    self._gameBoard = Array2D(8, 8)

    self._gameBoard.clear(EMPTY)

   

     # Set the initial configuration of the board.

    self._gameBoard[4,3] = BLACK

    self._gameBoard[3,4] = BLACK

    self._gameBoard[3,3] = WHITE

    self._gameBoard[4,4] = WHITE

     # Maintain the number of the current player.

    self._currentPlayer = BLACK

   

     # Keep track of the number of each players chips.

    self._numBlackChips = 2

    self._numWhiteChips = 2

   

     # A flag that is set when the game is over. That is, when there are

     # no empty squares on the board or neither player can make a move.

    self._gameOver = False

   

  # Returns a boolean indicating whether the game is over.

  def isOver(self) :

    isOver = 0

    for i in range(8) :

      for j in range(8) :

        if self._gameBoard[i, j] != 0 :

          isOver + 1

    if isOver == 64 :

        self._gameOver = True

        return True

    else:

        return False

   

  # Returns the player number of the current player.

  def whoseTurn(self) :

    if self._currentPlayer == 1:

      return 1

    else:

      self._curentPlayer == 2

    return 2

     

   

  # Returns the number of chips on the board for the given player.

  def numChips(self, player) :

    chipCounter = 0

    if player == 1 :

      for i in range(8) :

        for j in range(8) :

          if self._gameBoard[i, j] == BLACK :

            chipCounter = chipCounter + 1

    else : 

      for i in range(8) :

        for j in range(8) :

          if self._gameBoard[i, j] == WHITE :

            chipCounter = chipCounter + 1 

    return chipCounter

   

  # Returns the number of open squares on the board.

  def numOpenSquares(self) :

    numOpenSquares = 0

    for i in range(8) :

      for j in range(8) :

        if self._gameBoard[i, j] == EMPTY :

          numOpenSquares =  numOpenSquares + 1

    return numOpenSquares

   

  # Returns the player number of the winner or 0 if it's a draw.

  def getWinner( self ):

    player1 = 0

    player2 = 0

    if self._gameOver is True :

      for i in range(8) :

        for j in range(8) :

          if self._gameBoard[i, j] == BLACK :

            player1 = player1 + 1

          else :

            player2 = player2 + 1

      if player1 > player2 :

        return 1

      if player2 > player1 :

        return 2

      else:

        return 0

  # Returns the 

  def isLegalMove( self, row, col):

    if row < 8 and col < 8:

      if self._gameBoard[row,col] != EMPTY:

        return True

    else:

      return False

     

   # Returns the player number whose chip occupies the given square.

  def occupiedBy(self, row, col):

    if self._gameBoard[row, col] == BLACK :

      return 1

    if self._gameBoard[row, col] == WHITE :

      return 2

    else:

      return 0

  # Performs an actual move in the game. That is the current player places

  # one of his chips in the square at position (row, col).

  def makeMove( row, col ):

    if isALineOfAttack(row, col, 1, 1) is True :

      if self._currentPlayer == 1 :

        self._gameBoard[row, col] = BLACK

      else :

        self._gameBoard[row, col] = WHITE 

     

       

         

   

   # Helper method that returns a Boolean indicating if there is a line of

   # attack from cell (row, col) in the direction offset given by rowInc

   # and colInc. The direction offsets should be, 0, 1, or -1.

  def _isALineOfAttack(self, row, col, rowInc, colInc) :

    row += rowInc

    col += colInc

     # The next cell in the line must contain the opponents chip.  

    if self.occupiedBy(row, col) == self._currentPlayer :

      return False

   

     # Traverse along the line and determine if it's a line of attack.

    while row >= 0 and col >= 0 and row < 8 and col < 8 :

      if self.occupiedBy(row, col) == self._currentPlayer :

        return True

      elif self.occupiedBy(row, col) == EMPTY :

        return False

      else :

        row += rowInc

        col += colInc

        if row < 0 or row > 7 or col < 0 or col > 7 :

              return False      

    return False


Tutor Answer

(Top Tutor) Daniel C.
(997)
School: Purdue University
PREMIUM TUTOR
Studypool has helped 1,244,100 students
Ask your homework questions. Receive quality answers!

Type your question here (or upload an image)

1821 tutors are online

Brown University





1271 Tutors

California Institute of Technology




2131 Tutors

Carnegie Mellon University




982 Tutors

Columbia University





1256 Tutors

Dartmouth University





2113 Tutors

Emory University





2279 Tutors

Harvard University





599 Tutors

Massachusetts Institute of Technology



2319 Tutors

New York University





1645 Tutors

Notre Dam University





1911 Tutors

Oklahoma University





2122 Tutors

Pennsylvania State University





932 Tutors

Princeton University





1211 Tutors

Stanford University





983 Tutors

University of California





1282 Tutors

Oxford University





123 Tutors

Yale University





2325 Tutors