Run simultaneous process inside python class

Question

I'm developping a game using pygame and I want to create a loading screen while the assets are loaded. The loading screen have animations, so loading screen and assets loading should be occurring at the same time.

Consider the code below:

class Game:
    def __init__(self):
       self.loading_screen()
       self.load_assets()
    def loading_screen(self):
       # do something while load_assets() is running
    def load_assets(self):
       # load all assets needed

I've tried Process from multiprocessing, but I dont know how to keep loading_screen() running without freezes while load_assets() are running.

Also, I've tried threads, but python doesn't run threads simultaneously, so, in some moment, the loading_screen() will freeze. (This could be wrong, but this was observed in the game)

Some help about this? Thanks for all

Answer 1

Threads are suitable for this. Nothing runs exactly simultaneously on a multi user system anyway.

import threading
from time import sleep

class Game:
    def __init__(self):
        self.loading_screen()
    def loading_screen(self):
        t = threading.Thread(target=self.load_assets)
        t.daemon = True
        t.start()
        while t.isAlive():
            sleep(0.1)
            print("loading screen")
        print ("assets done, ready to proceed now")

    def load_assets(self):
        i = 0
        while i < 10:
            print("loading assets")
            i += 1
            sleep(1)

g = Game()
print("done")

This puts your asset loading to a thread and then enters loading_screen() in the main thread. This just prints messages to demonstrate they both run in parallel.

Answer 2

I can understand what problems the OP is having, a preferred solution is to use multiprocessing rather than multithreading. The given demo from the first answer uses time.sleep for simulating 'heavy loading' in the loading function, but when loading is actually going to take place, it will take a major amount of performance out of the CPU. So it might happen that your loading animation is playing at 5-10 FPS when you expected 100+ FPS from it.

In this case, it is best to use multiprocessing to achieve the same. From what I have heard, it is a bit complicated to implement it, but it is quite possible. The loading function will then run as a separate process, not a separate thread from the same process.

Here is a small demo program to illustrate a loading screen using multiprocessing:

import multiprocessing
from multiprocessing.connection import Connection


def loading_screen(conn: Connection, stage):
    clock = pygame.time.Clock()
    fps = 60
    c = 0
    font = pygame.font.SysFont('consolas', 25)
    while True:
        screen.fill((0, 0, 50))
        events = pygame.event.get()
        for e in events:
            if e.type == pygame.QUIT:
                return
            if e.type == pygame.KEYDOWN:
                if e.key == pygame.K_ESCAPE:
                    return
        if conn.poll():  # check if any object is available to be received or not
            # this line is used to prevent waiting until the next object is received
            c = conn.recv()  # if available, receive the object
        if c == 'end':
            # process end condition checking
            return
        pygame.draw.rect(screen, 'white', (50, 50, c, 50))
        screen.blit(font.render(f'{c} / {stage * 100} %     [stage {stage}]', True, 'white'), (50, 150))
        screen.blit(font.render('Check console for status', True, 'white'), (50, 200))
        pygame.display.update()
        clock.tick(fps)
        pygame.display.set_caption(f'Multiprocessing Loading Screen [FPS = {int(clock.get_fps())}]')


def resource_load(conn: Connection, items):
    # load resources
    # for now it increments a counter and sends it via the connection object
    # you can replace it for CPU intensive processes
    # and pass the loaded objects to the connection object
    c = 0
    while True:
        c += 1
        if c > items:
            conn.send('end')  # signal end of loading current stage
            return  # returning will end the process automatically
        conn.send(c)  # send the counter value via the connection object


if __name__ == '__main__':
    import pygame

    pygame.init()

    screen = pygame.display.set_mode((500, 300))  # initialize display

    receiver, sender = multiprocessing.Pipe(duplex=False)  # initialize sender and receiver connection objects [unidirectional]

    print('Program to demonstrate a simple loading screen using multiprocessing')
    print()

    print('starting stages...')
    multiprocessing.Process(target=resource_load, args=(sender, 100)).start()
    print('loading stage 1')
    loading_screen(receiver, 1)
    multiprocessing.Process(target=resource_load, args=(sender, 200)).start()
    print('loading stage 2')
    loading_screen(receiver, 2)
    multiprocessing.Process(target=resource_load, args=(sender, 300)).start()
    print('loading stage 3')
    loading_screen(receiver, 3)
    input('finished loading all stages... press Enter to exit console')  # press Enter inside the console to exit program