#!/usr/bin/python

"""
Simplistic implementation of the board game reversi, better known as Othello.

The algorithm for determining legal moves is not particularly efficient since
no attempt is made to cache legal moves.
"""

"""
__version__ = "$Revision: 1.4 $"
__date__ = "$Date: 2004/10/10 01:20:21 $"
"""

from PythonCard import dialog, model
from random import randint
import time
import wx

EMPTY = None
BLACK = True
WHITE = False
BOARDWIDTH = BOARDHEIGHT = 8

DIRECTIONS = ((-1, -1), (0, -1), (1, -1),
              (-1, 0),           (1, 0),
              (-1, 1),  (0, 1),  (1, 1))

BOARDCOLOR = 'dark green'
CELLWIDTH = CELLHEIGHT = 37

class GameBoard:
    def __init__(self):
        self.initializeBoard()

    def initializeBoard(self):
        self.board = {}
        # the board references are column, row
        # to simplify x, y translation
        for column in range(BOARDWIDTH):
            for row in range(BOARDHEIGHT):
                self.board[(column, row)] = EMPTY
        self.board[(3, 3)] = WHITE
        self.board[(4, 4)] = WHITE
        self.board[(3, 4)] = BLACK
        self.board[(4, 3)] = BLACK
        
        # black always goes first
        self.nextMove = BLACK
        self.buildLegalMoves(self.nextMove)
        self.gameOver = False

    def opponentColor(self, color):
        if color == BLACK:
            return WHITE
        else:
            return BLACK

    def legalMove(self, column, row, color):
        """returns the number of pieces flipped if the move is legal
        otherwise it returns 0"""
        totalFlipped = 0
        if self.board[(column, row)] == EMPTY:
            opponent = self.opponentColor(color)
            # to be a legal move 
            #   the position must be empty
            #   the position must be adjacent to an opponent
            #     color piece
            #   searching in the direction of the opposing
            #     color piece there must be a position matching
            #     the starting position color
            #   the edges of the board don't count
            board = self.board
            for dx, dy in DIRECTIONS:
                flipped = 0
                x = column + dx
                y = row + dy
                if board.get((x, y), EMPTY) == opponent:
                    # now check to see if we run into our
                    # own color so we have something to flip
                    # if we run into an empty space or off the board
                    # then it isn't a legal move
                    while board.get((x, y), EMPTY) == opponent:
                        x += dx
                        y += dy
                        flipped += 1
                        if board.get((x, y), EMPTY) == color:
                            totalFlipped += flipped
        return totalFlipped

    def buildLegalMoves(self, color):
        """build a dictionary of legal moves with the (column, row) as the key
        and the number of pieces flipped as the value"""

        self.legalMoves = {}
        for column, row in self.board.keys():
            flipped = self.legalMove(column, row, color)
            if flipped:
                self.legalMoves[(column, row)] = flipped
        
    def legalMovesAvailable(self, color):
        self.buildLegalMoves(color)
        # look at all empty positions on the board to determine
        # whether any legal moves exist
        if self.legalMoves == {}:
            return False
        else:
            return True

    def makeMove(self, column, row, color):
        self.board[(column, row)] = color
        # now flip all the pieces        
        
        opponent = self.opponentColor(color)
        # to be a legal move 
        #   the position must be empty
        #   the position must be adjacent to an opponent
        #     color piece
        #   searching in the direction of the opposing
        #     color piece there must be a position matching
        #     the starting position color
        #   the edges of the board don't count
        board = self.board
        for dx, dy in DIRECTIONS:
            x = column + dx
            y = row + dy
            if board.get((x, y), EMPTY) == opponent:
                flip = []
                # now check to see if we run into our
                # own color so we have something to flip
                # if we run into an empty space or off the board
                # then it isn't a legal move
                while board.get((x, y), EMPTY) == opponent:
                    # add pieces to flip
                    flip.append((x, y))
                    x += dx
                    y += dy
                    if board.get((x, y), EMPTY) == color:
                        for position in flip:
                            board[position] = color
                        break
                    

        # change who has the next move
        # if there are no legal moves left for the opponent
        # then we check whether there are any legal moves
        # left for the current player
        # if neither has a legal move then the game is over
        if self.legalMovesAvailable(opponent):
            self.nextMove = opponent
        elif self.legalMovesAvailable(color):
            self.nextMove = color
        else:
            self.gameOver = True

    # computer is currently stupid and just
    # randomly picks from the available legal moves
    # if you lose then you're Mr. Gumby <wink>
    # what it should do instead is be able to use
    # various strategies such as flip the most pieces
    # favor certain positions like the edges but avoid the
    # the spots next to the corners (weighted positions)
    # okay, I added the flip the most pieces strategy
    # but it is still pretty dumb
    
    def doRandomComputerMove(self, color):
        legalMoves = self.legalMoves.keys()
        column, row = legalMoves[randint(0, len(legalMoves) - 1)]
        self.makeMove(column, row, color)

    def doFlipMostPiecesComputerMove(self, color):
        flipped = 0
        for position in self.legalMoves.keys():
            #print "  ", position, self.legalMoves[position]
            if self.legalMoves[position] > flipped:
                best = position
                flipped = self.legalMoves[best]
        #print "picked:", best, self.legalMoves[best], "\n"
        self.makeMove(best[0], best[1], color)

    def getScore(self):
        """return a tuple containing the number of 
        empty, black, and white squares"""
        score = {BLACK:0, WHITE:0, EMPTY:0}
        for value in self.board.values():
            score[value] += 1
        return score


class Reversi(model.Background):

    def on_initialize(self, event):        
        self.boardModel = GameBoard()
        self.components.bufOff.size = (BOARDWIDTH * CELLWIDTH + 1, BOARDHEIGHT * CELLHEIGHT + 1)
        self.singleItemExpandingSizerLayout()
        
        self.drawBoard()
        self.updateStatus()
        
        self.player = BLACK
        self.computer = WHITE
        self.lastHover = None
        if self.computer == BLACK:
            self.boardModel.doComputerMove(BLACK)


    def computerMove(self):
        if self.menuBar.getChecked('menuStrategyFlipMostPieces'):
            self.boardModel.doFlipMostPiecesComputerMove(self.computer)
        else:
            self.boardModel.doRandomComputerMove(self.computer)
        # sleep for a second to make it appear
        # the computer thought long and hard on her choice :)
        time.sleep(1)
        self.drawBoard()
        self.updateStatus()

    def newGame(self):
        self.boardModel.initializeBoard()
        self.drawBoard()
        self.updateStatus()
        if self.computer == BLACK:
            self.computerMove()

    def drawCell(self, x, y, state):
        view = self.components.bufOff
        if state in [BLACK, WHITE]:
            if state == BLACK:
                color = 'black'
            else:
                color = 'white'
            view.fillColor = color
            center = (x * CELLWIDTH + CELLWIDTH / 2 + 1, y * CELLHEIGHT + CELLHEIGHT / 2 + 1)
            view.drawCircle(center, round((CELLWIDTH / 2.0) - 3))
        else:
            view.fillColor = BOARDCOLOR
            view.foregroundColor = BOARDCOLOR
            view.drawRectangle((x * CELLWIDTH + 1, y * CELLHEIGHT + 1), (CELLWIDTH - 2, CELLHEIGHT - 2))
            view.foregroundColor = 'black'
        
    def drawBoard(self):
        view = self.components.bufOff
        view.autoRefresh = False
        view.backgroundColor = BOARDCOLOR
        view.clear()
        # draw the right and bottom edge borders
        view.drawLine((0, BOARDHEIGHT * CELLHEIGHT), (BOARDWIDTH * CELLWIDTH, BOARDHEIGHT * CELLHEIGHT))
        view.drawLine((BOARDWIDTH * CELLWIDTH, 0), (BOARDWIDTH * CELLWIDTH, BOARDHEIGHT * CELLHEIGHT))
        for x in range(BOARDWIDTH):
            view.drawLine((x * CELLWIDTH, 0), (x * CELLWIDTH, BOARDHEIGHT * CELLHEIGHT))
            for y in range(BOARDHEIGHT):
                view.drawLine((0, y * CELLHEIGHT), (BOARDWIDTH * CELLWIDTH, y * CELLHEIGHT))
                state = self.boardModel.board[(x, y)]
                self.drawCell(x, y, state)
        view.autoRefresh = True
        view.refresh()
        if wx.Platform == '__WXMAC__':
            # Mac won't update screen even after a Blit 
            # until the event handler ends, so we have to force an update
            view.redraw()

    def updateStatus(self):
        if self.boardModel.gameOver:
            score = self.boardModel.getScore()
            playerScore = score[self.player]
            computerScore = score[self.computer]
            scoreString = "Black: %d  White: %d" % (score[BLACK], score[WHITE])
            if playerScore > computerScore:
                message = "Player won!"
            elif playerScore < computerScore:
                message = "Computer won!"
            else:
                message = "Tie Game"
            status = message + "  -  " + scoreString
        else:
            if self.boardModel.nextMove == BLACK:
                status = "Black's move"
            else:
                status = "White's move"
        self.statusBar.text = status

    def on_bufOff_mouseMove(self, event):
        x, y = event.position
        x = x / CELLWIDTH
        y = y / CELLHEIGHT
        #if self.boardModel.legalMove(x, y, self.boardModel.nextMove):
        if (x, y) != self.lastHover:
            # erase lastHover if needed
            if self.lastHover and self.boardModel.board[self.lastHover] is None:
                self.drawCell(self.lastHover[0], self.lastHover[1], EMPTY)
            # if the move is legal, show it
            if self.boardModel.legalMoves.get((x, y), None):
                self.drawCell(x, y, self.player)
            # don't track positions outside the valid range
            if (x >= 0 and x < BOARDWIDTH) and (y >= 0 and y < BOARDHEIGHT):
                self.lastHover = (x, y)

    def on_bufOff_mouseUp(self, event):
        x, y = event.position
        # this is a simplistic translation
        # when users click on the lines
        # separating cells they may get a cell
        # they didn't expect
        x = x / CELLWIDTH
        y = y / CELLHEIGHT
        if self.boardModel.legalMove(x, y, self.boardModel.nextMove):
            self.boardModel.makeMove(x, y, self.boardModel.nextMove)
            self.drawBoard()
            self.updateStatus()
            if not self.boardModel.gameOver:
                if self.boardModel.nextMove == self.computer:
                    self.computerMove()
        event.skip()

    def on_menuFileNewGame_select(self, event):
        self.newGame()


if __name__ == '__main__':
    app = model.Application(Reversi)
    app.MainLoop()