Question

I am having an issue formulating an idea on how to work this problem. Please help.

My project consists of an N x N grid with a series of blocks that are supposed to move in a random direction and random velocity within this grid (every .1 seconds, the location of the block is updated with the velocity). I have three “special” blocks that are expected to have individual movement functions. I will have other blocks (many of them) doing nothing but updating their location, and making sure they remain in the grid.

Now these three blocks have functions beyond movement, but each of these runs individually, waiting for the other block’s special function to finish (block 2 will wait on block 1, Block 3 will wait on 2 and set it back to block 1, etc.) This queue of sorts will be running while the motion is happening. I want the motion to never stop. After each block’s non-movement function runs n times, the code finishes.

My question is this: should I use threads to start and stop the non-movement functions, or is there a way to just set a time and set booleans that could use a class function after .1 seconds to continuously move the objects (and obviously loop over and over), and then use counts to end the program all together? If so, how would you write main function for this in Python? For all of this happening, does anyone think that Java would be significantly faster than Python in running this, especially if writing the data to a .txt file?

Answer 1

Your best bet is probably to handle all of them at once in a single update function rather than attempting to use Threads. This is primarily because the Global Interpreter Lock will prevent multiple threads from processing concurrently anyway. What you’re after then is something like this:

def tick():
  for box in randomBoxes:
    box.relocate()

  specialBlock1.relocate()

  specialBlock2.relocate()

  specialBlock3.relocate()

Then we define a second function that will run our first function indefinitely:

def worker():
  while True:
    tick()

    sleep(0.1)

Now that we have an interval or sorts, we’ll launch a Thread that runs in the background and handles our display updates.

from threading import Thread

t = Thread(target = worker, name = "Grid Worker")

t.daemon = True # Useful when this thread is not the main thread.

t.start()

In our tick() function we’ve worked in the requirements that specialBlocks 1, 2, and 3 are working in a set order. The other boxes each take their actions regardless of what the others do.