Add some missing parts.

Demonstrate on-the-fly flip for sprites.

Make distinctions between internal and external (downloaded from
third-party servers).

Make use of sprite loading to streamline the sprite management process.

Add custom enums for making sense of returned values from config and
game app code.

Remove symlinks and make codebase use common modules instead.

Unify config loading in net and video subsystems.

Make sure to have help messages for both the game and the server.

Make the member name generic to accommodate other potential
implementations beyond Websockets.

Use appropriate identifier for function that runs network thread.

Put input and video subsystems into their own directories.

Split the network events to the net directory to keep the app code
implementation clean.

Ensure no side effect persists when errors have been triggered.

Implement the sending of input events to the websocket server.

Use common method for creating messages in client and server.

Make server optionally have a mountpoint for putting assets.

Copy implementation from lws.

Connect client to server, save connection details.

Ensure app pointer is present in callbacks.

With the help of the test client app, the real client is able to receive
messages which are transmitted through the server.

Ensure the same reference of the server is terminated in the server,
while the client should check the context when connecting/disconnecting.

Attempt to connect client to server.

Split callback logic into several functions.

Update initialization method.

The client app is able to connect to the server, however no further
communication is happening. Must've been the callbacks?

Also the client app enters into an infinite loop when lws_service() is
called inside the game loop.

Add libwebsockets client to game executable.

Only check if events should break the game loop instead of having a
separate member for game loop checking.

Delegate the event handling solely in input state.

Add tests for initialization and teardown for all input methods.

Add memory and data-related implementations for handling game data.

Properly mock video function dependencies.

Correctly dereference pointers.

Update input tests.

Declare memory before processing.

Declare variables early on.

Use short names for int types.

The game now uses MIDI support for alternative input methods.

Put I/O values to their respective structs.

Ensure each initialization method is in its own source.

Determine config path only once.

Make device handling opt-in.

Honor the FPS cap with updating video. Now the update occurs after
processing all the input actions.

Implement event handling for gamepads and joysticks.

In addition, the events are ordered according to SDL compatibility.

Extract config-related code to their own source files.