Python turtle Reversi Othello

小鱼儿 2023-10-04 16:13 54阅读 0赞

import turtle
    
    
    # Initializing Board
    # Dorost Kardane Board
    def initialiseBoard(n):
        board = []
        board = [[0 for i in range(n)] for j in range(n)]
        half = int(n / 2)
        board[half - 1][half - 1] = 1
        board[half - 1][half] = -1
        board[half][half - 1] = -1
        board[half][half] = 1
        return board
    
    
    # Making GUI Playing Board And User Interface With Turtle
    # Dorost Kardane Mohit Bazi Va neveshtar haye marboot be mohit karbari
    def drawBoard(boardSize, t):
        t.hideturtle()
        t.speed(0)
        t.penup()
        t.right(90)
        t.forward(240)
        t.left(90)
        t.forward(240)
        t.left(90)
        t.pendown()
        t.forward(480)
        t.left(90)
        for coln in range(boardSize):
            t.forward(480 / boardSize)
            t.left(90)
            t.forward(480)
            t.backward(480)
            t.right(90)
    
        t.left(90)
    
        for row in range(boardSize):
            t.forward(480 / boardSize)
            t.left(90)
            t.forward(480)
            t.backward(480)
            t.right(90)
    
        t.penup()
    
        for row in range(boardSize):
            t.pencolor("black")
            t.goto(-250, (240 - (row) * 480 / boardSize - 480 / boardSize / 3 * 2))
            t.write(str(row + 1), False, align='center', font=("Arial", 12, "normal"))
    
        for coln in range(boardSize):
            t.pencolor("red")
            t.goto((-240 + coln * 480 / boardSize + 480 / boardSize / 2), 250)
            t.write(chr(coln + 65), False, align='center', font=("Arial", 12, "normal"))
    
    
    # Adding taws to the playing board
    # Ezafe Kardane Mohre ha
    def updateScreen(b):
        boardSize = len(b)
        t = turtle.Turtle()
        t.speed(0)
        t.hideturtle()
        t.shapesize(480 / boardSize / 25)
        t.pencolor("black")
        t.shape("circle")
        t.penup()
        for row in range(boardSize):
            for coln in range(boardSize):
                if (b[row][coln] > 0):
                    t.goto(480 / boardSize * coln - 240 + 480 / boardSize / 2,
                           480 / boardSize * row - 240 + 480 / boardSize / 2)
                    t.fillcolor("black")
                    t.stamp()
                if (b[row][coln] < 0):
                    t.goto(480 / boardSize * coln - 240 + 480 / boardSize / 2,
                           480 / boardSize * row - 240 + 480 / boardSize / 2)
                    t.fillcolor("red")
                    t.stamp()
        return
    
    
    def move(b, m, p):
        r = m[0]
        c = m[1]
        if (len(m[2]) == 0):
            return
        else:
            for move in m[2]:
                newR = r + move[0]
                newC = c + move[1]
                while (b[newR][newC] != abs(b[newR][newC]) * p):
                    b[newR][newC] = (abs(b[newR][newC]) + 1) * p
                    newR = newR + move[0]
                    newC = newC + move[1]
            b[r][c] = p
            # placePiece(b, r, c, p)
            updateScreen(b)
    
    
    def legalDirection(r, c, b, p, u, v):
        foundOpponent = False
        while (r >= 0 and r <= len(b) and c >= 0 and c <= len(b)):
            r = r + u
            c = c + v
            if (r < 0 or r >= len(b) or c < 0 or c >= len(b)):
                return False
            if (b[r][c] == 0):
                return False
            if (b[r][c] == abs(b[r][c]) * p):
                if foundOpponent:
                    return True
                else:
                    return False
            if (b[r][c] != abs(b[r][c]) * p):
                foundOpponent = True
        return False
    
    
    def legalMove(r, c, b, p):
        legalDirections = []
        if (b[r][c] != 0):
            return legalDirections
        if (legalDirection(r, c, b, p, -1, -1)):
            legalDirections.append((-1, -1))
        if (legalDirection(r, c, b, p, -1, 0)):
            legalDirections.append((-1, 0))
        if (legalDirection(r, c, b, p, -1, 1)):
            legalDirections.append((-1, 1))
        if (legalDirection(r, c, b, p, 0, -1)):
            legalDirections.append((0, -1))
        if (legalDirection(r, c, b, p, 0, 0)):
            legalDirections.append((0, 0))
        if (legalDirection(r, c, b, p, 0, 1)):
            legalDirections.append((0, 1))
        if (legalDirection(r, c, b, p, 1, -1)):
            legalDirections.append((1, -1))
        if (legalDirection(r, c, b, p, 1, 0)):
            legalDirections.append((1, 0))
        if (legalDirection(r, c, b, p, 1, 1)):
            legalDirections.append((1, 1))
        return legalDirections
    
    
    def moves(b, p):
        availableMoves = []
        for r in range(len(b)):
            for c in range(len(b)):
                legal = legalMove(r, c, b, p)
                if legal != []:
                    availableMoves.append((r, c, legal))
        return availableMoves
    
    
    def scoreBoard(b):
        blackScore = 0
        redScore = 0
        for r in range(len(b)):
            for c in range(len(b)):
                if (b[r][c] > 0):
                    if b[r][c] > 0:
                        blackScore = blackScore + b[r][c]
                if (b[r][c] < 0):
                    if b[r][c] < 0:
                        redScore = redScore - b[r][c]
        return (blackScore, redScore)
    
    
    def checkMoveScore(b, m,
                       p):  # Goes through all possible moves and finds the one with the highest score. The computer will choose this one.
        moveScore = 1
        r = m[0]
        c = m[1]
        if (len(m[2]) == 0):
            return 0
        else:
            for move in m[2]:
                newR = r + move[0]
                newC = c + move[1]
                while (b[newR][newC] != abs(b[newR][newC]) * p):
                    moveScore = moveScore + abs(b[newR][newC])
                    newR = newR + move[0]
                    newC = newC + move[1]
        return moveScore
    
    
    def selectMove(b, availableMoves, p):
        bestMoveScore = 0
        bestMoveIndex = -1
        currentMoveIndex = 0
        for availableMove in availableMoves:
            currentMoveScore = checkMoveScore(b, availableMove, p)
            if (bestMoveScore < currentMoveScore):
                bestMoveIndex = currentMoveIndex
                bestMoveScore = currentMoveScore
            currentMoveIndex = currentMoveIndex + 1
        return availableMoves[bestMoveIndex]
    
    
    def main():
        playing = True
        while playing:
            board = []
            while (board == []):
                try:
                    screen = turtle.Screen()
                    screen.clear()
                    board = initialiseBoard(8)
                except:
                    print("Enter a valid number.")
                    pass
    
            t = turtle.Turtle()
            t.hideturtle()
            turtleText = turtle.Turtle()
            turtleText.hideturtle()
            turtleText.penup()
            turtleText.speed(0)
            turtle.title("Othello")
            turtle.setup(800, 600)
            screen.bgcolor("darkgreen")
            drawBoard(8, t)
            updateScreen(board)
            playerTurn = 1
            gameOver = False
            blackCanMove = True
            redCanMove = True
            while (not gameOver):
                if playerTurn == -1:
                    print("Player Red's turn.")
                else:
                    print("Player black's turn.")
                scores = scoreBoard(board)
                turtleText.clear()
                turtleText.pencolor("black")
                turtleText.goto(-280, 280)
                turtleText.write("Black: " + str(scores[0]), False, align='center', font=("Arial", 12, "bold"))
                turtleText.pencolor("Red")
                turtleText.goto(280, 280)
                turtleText.write("Red: " + str(scores[1]), False, align='center', font=("Arial", 12, "bold"))
                validMove = False
    
                if (not blackCanMove or not redCanMove):
                    print("GAME OVER!")
                    if scores[0] > scores[1]:
                        print("Black wins!")
                    else:
                        print("Red wins!")
                    gameOver = True
    
                while (not validMove):
                    inRange = False
                    while (not inRange):
                        r = -1
                        try:
                            r = 8 - int(input("Row of new piece: "))
                        except:
                            print("Enter a valid number in range.")
                            pass
                        if (r >= 0 and r < 8):
                            inRange = True
                        else:
                            print("Enter a valid number in range.")
                    inRange = False
                    while (not inRange):
                        c = input("Column of new piece: ")
                        c = c.upper()
                        try:
                            c = ord(c) - ord('A')
                            if (c >= 0 and c < 8):
                                inRange = True
                            else:
                                print("Enter a valid letter in range.")
                        except:
                            print("Enter a valid letter in range.")
                            pass
                    availableMoves = [r, c, legalMove(r, c, board, playerTurn)]
                    if (availableMoves[2] != []):
                        validMove = True
                        move(board, availableMoves, playerTurn)
                    else:
                        print("Invalid move.")
                if playerTurn == -1:
                    playerTurn = 1
                else:
                    playerTurn = -1
            playAgain = -1
            while (playAgain < 1 or playAgain > 2):
                try:
                    print("Play again?")
                    print("1. yes")
                    print("2. no")
                    playAgain = int(input(""))
                    if playAgain == 2:
                        playing = False
                except:
                    pass
        return
    
    
    main()

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FsbHdheTI_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FsbHdheTI_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FsbHdheTI_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210611222745892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FsbHdheTI=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FsbHdheTI_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210611152201488.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FsbHdheTI=,size_16,color_FFFFFF,t_70