python: Threading-Klassen aus der Klasse main_window

Question

Ich versuche, ein Spiel mit Tkinter zu erstellen, das Funktionen aus mehreren Klassenobjekten gleichzeitig mit Threads ausführen kann. In der MainWindow-Klasse habe ich "player" und "player2" der Klasse "Player" zugewiesen.

In der Klasse "Player" haben Sie eine Funktion namens "move", die das Canvas-Objekt einfach verschiebt.

Wenn die rechte Taste gedrückt wird, beginnt "player" sich zu bewegen. Sobald jedoch die linke Taste gedrückt wird, scheint "player" als Ersatz für "player2" gestoppt zu sein.

Gibt es trotzdem, um das zu beheben?

from tkinter import * 
from threading import Thread 
import time 


class MainWindow(Frame): 
    def __init__(self , parent): 
     self.backround = '#%02x%02x%02x' % (180, 180, 180) 
     self.main_width = 1905 
     self.main_height = 1002 

     Frame.__init__(self , parent , bg = self.backround) 
     self.pack(fill=BOTH, expand=1) 
     self.parent = parent 
     self.parent.geometry('1905x1002+0+0') 
     self.main_canvas = Canvas(self , width = self.main_width , height =  
     self.main_height , bg = 'white') 
     self.main_canvas.pack() 

     self.Keyboard_Events = Thread(target = self.keyboard_events) 
     self.Keyboard_Events.start() 

Spieler

 self.player = Player(self.main_canvas , [125 , 125] , self) #(canvas , coords) 
     self.player2 = Player(self.main_canvas , [200 , 100] , self) #(canvas , coords) 

Rückrufe

def keyboard_events(self): 
     def callback_mouse_primary(event): 
      self.player.move(0.01) 
     def callback_mouse_secondary(event): 
      self.player2.move(0.01) 

     root.bind('<Button-1>' , callback_mouse_primary) 
     root.bind('<Button-3>' , callback_mouse_secondary) 

Spielerklasse

class Player(Thread): 
    def __init__(self , canvas , coords , parent): 
     Thread.__init__(self) 
     self.setDaemon(True) 
     self.canvas = canvas 
     self.coords = coords 
     self.player_object = self.canvas.create_rectangle(self.coords[0]-25 , self.coords[1]-25 , self.coords[0]+25 , self.coords[1]+25) 

    def move(self , Time): 

     for y in range(100): 
      self.canvas.coords(self.player_object , self.coords[0]-25 , self.coords[1]-25 , self.coords[0]+25 , self.coords[1]+25) 
      self.coords[0] += 0.1 
      self.coords[1] += 0.1 
      self.canvas.update() 
      time.sleep(Time) 

    def Print_info (self): 
     print (self.coords) 

if __name__ == '__main__': 
    root = Tk() 
    main = MainWindow(root) 
    root.mainloop() 

einfach deutlich zu machen. Player-Objekte werden innerhalb der MainWindow-Klasse erstellt und Funktionen innerhalb dieser Player werden innerhalb der MainWindow-Klasse ausgeführt. Gibt es eine Möglichkeit, diese Player-Objekte so zu routen, dass sie unabhängig voneinander laufen?

Answer 1

1) Ihre Notwendigkeit, Ihr Modell zu beheben und eine Trennung zwischen dem Modell/Daten und die Darstellung/Visualisierung:

players müssen nur ihre Daten zu halten, und nicht verantwortlich zu sein, etwas für das Zeichnen. Sie sollten über eine Haupt-Rendering-Schleife verfügen, die die Komponenten auf dem Display liest und entsprechend positioniert.

2) players sind nicht threads und es ist nicht notwendig, sie zu dämonisieren. Threads läuft als ein separater Prozess. In Ihrem Fall der separate Prozess ist es, die Spieler mit einer bestimmten Geschwindigkeit in Bewegung zu setzen, daß das Sein:

def callback_mouse_primary(event): 
     t=Thread(target=self.player.move,kwargs={'Time': 0.01}) 
     t.start()