Using pygame with multiple threads

Question

I have decided to try out pygame. I created a class that is supposed to handle all the GUI and game related stuff.

My idea is that I would have two seperate threads. One to handle the GUI and one to handle all the calculations the game does in the background.

import threading
import pygame
import pygame_gui


class Game ():


    engine_running = True
    gui_running = True
    clock = pygame.time.Clock()

    gui_framerate = 60.0
    engine_framerate = 120.0

    def __init__(self):

        pygame.init()
        pygame.display.set_caption('Explodotech')
        self.window_surface = pygame.display.set_mode((800, 600))
        self.background = pygame.Surface((800, 600))
        self.background.fill(pygame.Color('#000000'))

        self.manager = pygame_gui.UIManager((800, 600))

        ### Define GUI Elements here

        self.quit_button = pygame_gui.elements.UIButton(relative_rect=pygame.Rect((650, 500),
                        (100, 50)), text='Quit', manager=self.manager,                         
                        tool_tip_text = "Quit the game")

        ### Create and start the threads
        self.gui_thread = threading.Thread(target = self.gui_loop)
        self.engine_thread = threading.Thread(target = self.engine_loop, args = [])

        self.gui_thread.start()
        self.engine_thread.start()


    def start_polling(self):
        """Starts the main loop"""
        self.engine_running = True

    def stop_polling(self):
        """Stops the main loop"""
        self.engine_running = False

    def gui_loop(self):
        """Managing all the GUI stuff"""

        print ("GUI-loop started!")

        while self.gui_running:
            print("Polling GUI")
            dT = self.clock.tick_busy_loop(60)/1000.0

            for event in pygame.event.get():

                if event.type == pygame.QUIT:
                    self.gui_running = False

                if event.type == pygame.USEREVENT:
                    if event.user_type == pygame_gui.UI_BUTTON_PRESSED:
                        if event.ui_element == self.quit_button:
                            self.quit_button_event()

                self.manager.process_events(event)

            self.manager.update(dT)

            self.window_surface.blit(self.background, (0, 0))
            self.manager.draw_ui(self.window_surface)

            pygame.display.update()

    def engine_loop(self):
        """Doing all the game calculations in the background"""
        while self.engine_running:
            print(self.clock.tick_busy_loop(1))
        

    ### Define GUI events here

    def quit_button_event(self):
        """Shut down the GUI"""
        print("Quit-button pressed!")
        self.gui_running = False
        self.engine_running = False

Basically what's happening here is that I have two threads one should run the "gui_loop" function the other should run the "engine_loop". However when the gui thread starts and gets into its while-loop it get stuck. The windows goes unresponsive and I have to force windows to shut it down. However if I a create a Game-object and call the function directly it all works fine (obviously commenting out the party where I create the Thread-object):

g = Game()
g.gui_loop()

Any pointers what I am doing wrong would be greatly appreciated!

Answer 1

Your program gets stuck after closing because you only stop the engine, not the Python program.

You need to exit the system as follows:

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        pygame.quit()
        sys.exit()

Answer 2

Python is an interpreted language, and there's a thing called Global Interpreter Lock, which prevents multiple threads to run Python code simultaneously. (See details in Documentations of threading module.) If you run two full while loops in a single Python process, one of them is going to block another. You GUI freezes because your core loop blocked it. My computer, on the other hand, won't freeze the GUI, but the core thread won't run because the GUI thread blocked it.

You can have two ways around this:

1. Try combine two while loops into one, run the higher frequency one as main loop, and count how many time it has looped to occasionally run the lower frequency update.

    [Pseudo Code]
    update(self):
      dt = self.get_dt(self.core_freq)
      self.update_core()
      self.accumulated_dt += dt
      if self.accumulated_dt > 1/self.gui_freq:
        self.update_gui()
        self.accumulated_dt = 0
   

2. Use multiprocessing to create multiple processes, and communicate between to share data. Python multiprocessing gets around the GI Lock by create more processes, but communicating between them can be costly and dangerous (causing data races). So, I won't suggest you to make a game with it. Complex mechanisms like this should really be handled at engine level.

Answer 3

I am not sure why your code doesn't run correctly on your pc; it runs perfectly fine on mine.

Maybe your CPU doesn't support multithreading, or just doesn't have enough cores. My pc has 8 cores with 16 threads, not sure about your PC.