OthelloGameLogic.py

#Alex Lin 47142386
NONE = ' '
BLACK = 'B'
WHITE = 'W'
DIRECTIONS = [[1,1],[0,1],[1,0],[1,-1],[0,-1],[-1,-1],[-1,0],[-1,1]]

class InvalidMove(Exception):
    pass

class Othello(object):

    def __init__(self, default, row, column, position, win_input):
        board = []
        self.win_choice = win_input
        if default == 'Black':
            self.turn = 'B'
        elif default == 'White':
            self.turn = 'W'
        self.board = board
 #       self.turn = default
        self._row = int(row)
        self._column = int(column)
        if position == 'Black':
            self.position = 'B'
        elif position == 'White':
            self.position = 'W'


    def winner_choice(self, choice):
        if self.b_score == self.w_score:
            return('Game ends with a tie')
        if choice == 'Most':
            if self.b_score > self.w_score:
                return('Black wins')
            else:
                return('White wins')
        elif choice == 'Least':
            if self.b_score > self.w_score:
                return('White wins')
            else:
                return('Black wins')

    def is_valid(self, row, column)-> bool:

        if self.on_board(row, column):
            try:
                if self.board[column][row] == NONE:
                    return True
            except IndexError:
                return False
        return False

    def on_board(self, row, column)-> bool:
        if row <= int(self._row-1) and column <= int(self._column-1) and row >= 0 and column >= 0:
            return True
        else:
           # print('Not on board')
            return False

    def check_direction(self, row, column)-> bool:
        possible = []
        result = False
        flip_test = []
        for d in DIRECTIONS:
            if self.on_board(row+d[0], column+d[1]):
                possible.append([row+d[0], column+d[1],d])
        for piece in possible:
            row = piece[0]
            column = piece[1]
            if self.board[column][row] == self._opposite_player():
                if self._check_possible(piece[0],piece[1], piece[2]) != False:
                    flip_test.append(piece)
        for flipping in flip_test:
            result = self._to_flip(flipping[0], flipping[1], flipping[2])
        return result

    def _check_possible(self, row, column, d_check):
        while True:
            row += d_check[0]
            column += d_check[1]
            if self.on_board(row, column):
                if self.board[column][row] == self.turn:
                    return column, row
                elif self.board[column][row] == self._opposite_player():
                    pass
                else:
                    break
            else:
                break
        return False

    def _get_score(self):
        self.b_score = 0
        self.w_score = 0
        for row in range(self._row):
            for column in range(self._column):
                if self.board[column][row] == 'B':
                    self.b_score += 1
                elif self.board[column][row] == 'W':
                    self.w_score += 1
        print('Score: ')
        print('B:',self.b_score)
        print('W:',self.w_score)

    def _to_flip(self, row, column, d):
        result = False
        while self.on_board(row, column):
            if self.board[column][row] == self._opposite_player():
                self.board[column][row] = self.turn
                result = True
                pass
            elif self.board[column][row] == self.turn:
                break
            else:
                pass
            row += d[0]
            column += d[1]

        return result

    def _get_color(self, row, column)-> str:
        if self.board[column][row] == 'B':
            return 'Black'
        elif self.board[column][row] == 'W':
            return 'White'
        else:
            return

    def _get_color_no_str(self, row, column):
        return self.board[column][row]

    def _opposite_player(self)-> str:
    #Returns opposite player as string
        if self.turn == 'B':
            return 'W'
        elif self.turn == 'W':
            return 'B'
        else:
            pass

    def _opposite_player_position(self)-> str:
    #Returns opposite player as string
        if self.position == 'B':
            return 'W'
        elif self.position == 'W':
            return 'B'
        else:
            pass
    def place_move(self, row, column):
        if self.is_valid(row, column):
            if self.check_direction(row, column):
                print('Placing move in row',row+1, 'column', column+1)
                self.board[column][row] = self.turn
                self._switch_turn()
 #               self.print_game()
            else:
                print('Could not place the move at location specified.')
        else:
            print('Could not place the move at location specified.')

    def _switch_turn(self):
        if self.turn == 'B':
            self.turn = 'W'
        elif self.turn == 'W':
            self.turn = 'B'

    def new_game_board(self):
        MIDDLE_COLUMN = int(self._column/2)
        MIDDLE_ROW = int(self._row/2)
        board = []
        for col in range(self._column):
            board.append([])
            for row in range(self._row):
                board[-1].append(NONE)
        board[MIDDLE_COLUMN-1][MIDDLE_ROW-1] = self.position
        board[MIDDLE_COLUMN][MIDDLE_ROW] = self.position
        board[MIDDLE_COLUMN][MIDDLE_ROW-1] = self._opposite_player_position()
        board[MIDDLE_COLUMN-1][MIDDLE_ROW] = self._opposite_player_position()
        self.board = board
        return self.board

    def print_game(self):
        for row in range(self._row):
            print(row+1, end = '___ ')
        print()
        row_display = 1
        for row in self.board:
            for space in row:
                if space == ' ' or space == '':
                    print('|___|', end = '')
                else:
                    print('[',space,']', end = '')
            print(row_display)
            row_display += 1

    def _valid_turn(self)-> bool:
        check_piece = []
        valid_move = []
        check_piece = []
        vpiece = []
        for row in range(self._row):
            for column in range(self._column):
                if self.board[column][row] == self.turn:
                    check_piece.append([row, column])
        for piece in check_piece:
            if self._check_valid(piece[0], piece[1]) != False:
                vpiece.append(self._check_valid(piece[0], piece[1]))
        if not vpiece:
            return False
        else:
            return True

    def _check_valid(self, row, column):
        self._check = self.turn
        valid = []
        valid_moves = []
        for d in DIRECTIONS:
            check_r = row+d[0]
            check_c = column+d[1]
            if self.on_board(check_r, check_c):
                if self.board[check_c][check_r] == self._opposite_player():
                    valid.append([check_r, check_c, d])
        for val in valid:
            row = val[0]
            col = val[1]
            self.turn = NONE
            if self._check_possible(row, col, val[2]) != False:
                valid_moves.append(self._check_possible(row, col, val[2]))
        self.turn = self._check
        if not valid_moves:
            return False
        else:
            return valid_moves

    def _get_score(self):
        self.b_score = 0
        self.w_score = 0
        for row in range(self._row):
            for column in range(self._column):
                if self._get_color(row, column) == 'Black':
                    self.b_score += 1
                elif self._get_color(row, column) == 'White':
                    self.w_score += 1

    def _current(self):
        if self._valid_turn():
            if self.turn == 'B':
                return 'Black\'s turn to place a move'
            elif self.turn == 'W':
                return 'White\'s turn to place a move'
        else:
            self._switch_turn()
            if self._valid_turn():
                return ('{} has no available moves, {}s turn to move'.format(self._opposite_current_turn(),self._current_turn()))
            else:
                winner = self.winner_choice(self.win_choice)
                print(winner)
                return winner
                self._game_end = True
    def _current_turn(self):
        if self.turn == 'B':
            return 'Black'
        elif self.turn == 'W':
            return 'White'
    def _opposite_current_turn(self):
        if self.turn == 'B':
            return 'White'
        elif self.turn == 'W':
            return 'Black'
    def _empty_board(self):
        b = []
        for row in range(self._row):
            for column in range(self._column):
                if self._get_color(row, column) != None:
                    b.append(self._get_color(row, column))
            return True
        else:
            return False