tkinter 按钮颜色不会改变（非点击事件）

Question

I created a program to move a knight around a chess board touching every square without touching the same one twice, starting from a random location. I am attempting to show this action using tkinter by changing the color of the square (which is a button) to red as the knight moves.

The Chess Board is made of tkinter buttons and they relate to the "Square" class. The program sets the correct colors when creating the grid, but won't change them during execution.

Here is the reduced code (as instructed to provide). The reduced code is not the entire code, just the instance of creating the board and placing the knight in a random location. When the knight is placed, the button color should change.

    from tkinter import *
    from tkmacosx import Button
    import random
    import sys

    WIDTH = 800
    HEIGHT = 1000
    GRID_SIZE = 8


    class Square:
        board = []
        def __init__(self, x, y, touched=False):
            self.touched = touched
            self.board_btn_object = None
            self.x = x
            self.y = y
        
    
        def create_btn_object(self, location):
            btn = Button (
                location,
                width=100,
                height=100,
                text= f"{self.x}, {self.y}", 
                bg=None
            )
            self.board_btn_object = btn

            Square.board.append(self)
    
        @property
        def is_touched(self):
            self.touched = True
            self.board_btn_object.configure(bg="red")
    
        @staticmethod
        def randomlocation():
            return random.choice(Square.board)


        def __repr__(self):
            return f"Square({self.x}, {self.y}) touched={self.touched}"


    class Knight:
        def __init__(self, x, y):
            self.x = x
            self.y = y


    def main():
        root = Tk()
        root.configure(bg='blue')
        root.geometry(f'{WIDTH}x{HEIGHT}')
        root.title("chess chaser")
        root.resizable(False, False)

        top_frame = Frame(
            root,
            bg = "red",
            width = WIDTH,
            height = height_prct(10)
        )
        top_frame.place(x=0, y=0)

        bottom_frame = Frame(
            root,
            bg="black",
            width = WIDTH,
            height = height_prct(10)
        )
        bottom_frame.place(x=0, y=height_prct(90))

        center_frame = Frame(
            root,
            bg = "green",
            width = WIDTH,
            height = height_prct(80)
        )
        center_frame.place(
            x=0,
            y=height_prct(10)
        )

        make_board(center_frame)
        top_menu(top_frame)
    
        root.mainloop()


    def height_prct(percentage):
         return (HEIGHT / 100) * percentage


    def width_prct(percentage):
        return (WIDTH / 100) * percentage

    def top_menu(top_frame):

        run = Button (
            top_frame,
            width = 100,
            height = 50,
            text=f"Run",
            command = play_game
        )
        run.place(x=30, y=10)


    def make_board(center_frame):
        for x in range(GRID_SIZE):
            for y in range(GRID_SIZE):
                b = Square(x, y)
                b.create_btn_object(center_frame)
                b.board_btn_object.grid(
                    column=x, row=y
                )
                if (x+y) %2 ==0:
                    b.board_btn_object.configure(bg="grey50")
        return


    def play_game():
        knight = place_knight()
        sys.exit("Done")


    def place_knight():
        coords = Square.randomlocation()
        coords.is_touched
        x = coords.x
        y = coords.y
        knight = Knight(x, y)
        return knight


    if __name__ == "__main__":
        main()

I have tried using self.board_btn_object.change(bg="red") and.update and.after.... nothing works to change the color.

If I change code and bind left click to change the button to red, it works fine; however, I want it to change when the KNIGHT is positioned there.

Answer 1

You are just complicated everything. Create a cell class and keep information of x,y and iftouched in it. This way you can add new capabilities into cells easily. Create a board and make an array inside it. Create cell instances and place into that array. You should do inside this board whatever you do. Define rules, move capabilities etc. GUI simply should be an illusion of this imaginary board. When things get complicated you just update your user interface according to your board!

import tkinter as tk
import random

GRID_SIZE = 8

#this is cell which going to keep information
class cell:
    def __init__(self,x,y,IsTouched=False):
        self.x= x
        self.y = y
        self.touched = IsTouched

class board:
    def __init__(self):
        self.initializeBoard()
        self.knight = [0,0]
        self.placeKnightRandomly()
        
    def moveKnight(self,x,y):
        #if knight can move in the board, return True so that
        #we can show in the GUI.
        if(self.board[x][y].touched):
            return False
        else:
            self.knight = [x,y]
            print(f"Knight new position:{x},{y}")
            return True
    
    def initializeBoard(self):
        #This function creates board from zero.
        #if you want to reset board, simple run this function.
        self.board = []
        for row in range(GRID_SIZE):
            line = []
            for column in range(GRID_SIZE):
                line.append(cell(row,column))
            self.board.append(line)

    def placeKnightRandomly(self):
        #place knight randomly
        x = random.randint(0,7)
        y = random.randint(0,7)
        self.knight = [x,y]
        self.board[x][y].touched = True
        print("knight:",x,y)


class GUI:
    def __init__(self):
        self.mw = tk.Tk()
        self.mw.geometry("800x800")

        self.board = board()

        self.buttonFrame = tk.Frame(self.mw)
        self.buttonFrame.place(relx=0,rely=0,relheight=1,relwidth=1)

        self.updateButtons()
        self.mw.mainloop()

    def updateButtons(self):
        for child in self.buttonFrame.winfo_children():
            child.destroy()
        self.buttonsList = []
        for lines in self.board.board:
            
            buttons = []

            for column in lines:
                x = column.x
                y = column.y
                btn = tk.Button(self.buttonFrame,text=f"{x},{y}",width=12,height=5)
                if(self.board.board[x][y].touched):
                    btn.configure(bg="red")

                #lets connect a buttons to functions. Send x and y as parameters.
                btn.configure(command=lambda x = x,y=y:self.touchInto(x,y) )
                btn.grid(row=x,column=y)

                buttons.append(btn)

            self.buttonsList.append(buttons)
                
    def touchInto(self,x,y):
        #when you clicked button, this function going to run
        if(self.board.moveKnight(x,y)):
            self.board.board[x][y].touched = True
            self.buttonsList[x][y].configure(bg="red")
        else:
            print("cannot move!")



if __name__ == "__main__":
    GUI()

Answer 2

Create a cell class and keep information of your made varibales. This way you can add new capabilities into cells easily. Create a board and make an array inside it. Create cell instances and place into that array.