cargo-web | A Cargo subcommand for the client-side Web | Binary Executable Format library

In your example game_loop owns game, as it is moved into the loop. So anything that should change game needs to happen inside game_loop. To fit event handling into this, you have multiple options:

Let the game_loop poll for events.

You create a queue of events and your game_loop will have some logic to get the first event and handle it.

You will have to deal with synchronization here, so I suggest that you read up on Mutex and Concurrency in general. But it should be a fairly easy task once you get the hang of it. Your loop gets one reference and each event handler gets one, all try to unlock the mutex and then access the queue (vector probably).

This will make your game_loop the monolithic one truth of them all, which is a popular engine design because it is easy to reason about and start with.

But maybe you want to be less centralized.

Let events happen outside the loop

This idea would be a bigger refactor. You would put your Game in a lazy_static with a Mutex around it.

Every invocation of the game_loop it will try to get the lock on said Mutex and then perform game calculations.

When an input event happens, that event also tries to get the Mutex on the Game. This means while the game_loop is processing, no input events are handled, but they will try to get in between ticks.

A challenge here would be to preserve input order and to make sure that inputs are processed quick enough. This might be a bigger challenge to get completely right. But the design will give you some possibilities.

A fleshed out version of this idea is Amethyst, which is massively parallel and makes for a clean design. But they employ a quite more complex design behind their engine.