将PyQt交通仿真中的回合制移动函数改造为自动运行模式

Hey there! I totally get why you're running into crashes here—PyQt has a golden rule you might not have hit yet: never block the main GUI thread with long loops. Let's break down the problem and fix your automatic simulation.

Why Your Loops Are Causing Crashes #

PyQt runs your entire GUI in a single "event loop" thread. When you put a while loop directly in a button's click handler (like your next_full_turn call), that loop takes over the thread completely. The GUI can't update, process other clicks, or even redraw itself—so the OS thinks the program is frozen and kills it, or it just locks up.

The solution? We need to let the event loop breathe while running your simulation steps. The easiest way for a PyQt beginner is to use a QTimer to run each simulation turn in small, non-blocking chunks.

Step-by-Step Fix Using QTimer #

Here's how to modify your code to get automatic, crash-free simulation:

1. Add a QTimer to Your GUI Class #

First, initialize a timer in your GUI's constructor. This timer will trigger each simulation turn at a set interval.

# In your GUI class (GUI.py)
def __init__(self):
    # ... your existing initialization code ...
    self.simulation_timer = QtWidgets.QTimer(self)
    # Connect the timer's timeout signal to a function that runs one turn
    self.simulation_timer.timeout.connect(self.run_single_simulation_turn)

2. Create a Function to Run One Turn + Check for Completion #

This function will call your existing next_full_turn method, then check if all vehicles have reached their destination. If so, it stops the timer.

First, add a helper method to your World class to check if the simulation is done (adjust this based on how you track vehicle destinations):

# In your World class
def is_simulation_complete(self):
    # Replace this with your actual logic to check all vehicles
    for vehicle in self.get_all_vehicles():  # Assume you have a way to get all vehicles
        # Assume each vehicle has a method to check if it's at its destination
        if not vehicle.has_reached_destination():
            return False
    return True

Then add the turn-runner function to your GUI class:

# In your GUI class
def run_single_simulation_turn(self):
    # Run one full turn of your existing logic
    self.world.next_full_turn()
    
    # Check if we're done
    if self.world.is_simulation_complete():
        self.simulation_timer.stop()
        # Optional: Show a message when done
        QtWidgets.QMessageBox.information(self, "Simulation Done!", "All vehicles have reached their destinations.")

3. Update Your Button Binding #

Instead of connecting the start button directly to next_full_turn, connect it to a function that starts the timer. We'll also add a stop button for good measure.

# In your GUI's init_buttons method
def init_buttons(self):
    # Start Simulation Button
    start_button = QtWidgets.QPushButton("Start Simulation")
    start_button.clicked.connect(self.start_simulation)
    self.horizontal.addWidget(start_button)
    
    # Stop Simulation Button (optional but helpful)
    stop_button = QtWidgets.QPushButton("Stop Simulation")
    stop_button.clicked.connect(self.simulation_timer.stop)
    self.horizontal.addWidget(stop_button)

# Add this function to your GUI class
def start_simulation(self):
    # Only start if the timer isn't already running
    if not self.simulation_timer.isActive():
        # Set the interval (in milliseconds) between turns
        # Adjust this to make the simulation faster/slower
        self.simulation_timer.start(100)  # 100ms = 10 turns per second

Why This Works #

The QTimer doesn't block the event loop. Instead, it tells PyQt: "Every X milliseconds, when you have free time, run this simulation turn." Between turns, the GUI can update, respond to clicks, and stay responsive—no more crashes!

Advanced: Using Threads for Heavy Simulation #

If your next_full_turn takes a long time to run (e.g., hundreds of vehicles with complex logic), even the timer might cause slight GUI lag. In that case, you can move the simulation logic to a separate QThread and use signals to update the GUI. But for most beginner projects, the QTimer method is simpler and works great.

内容的提问来源于stack exchange，提问作者luntti