Put input and video subsystems into their own directories.

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

Database will be used for authentication.

Implement the sending of input events to the websocket server.

Update identifiers to be consistent.

Add subdirectories for grouping net-related functions.

Make server optionally have a mountpoint for putting assets.

Connect client to server, save connection details.

Attempt to connect client to server.

Isolate network logic to each subsystem.

Split callback logic into several functions.

Update initialization method.

Use ring example.

Use minimal server echo example instead.

Add libwebsockets client to game executable.

Protocol retrieved from lws git repo for samples.

Websockets server is for game networking.

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.

Update input tests.

The game now uses MIDI support for alternative input methods.

Put I/O values to their respective structs.

Isolate input items into their own directory.

Add spine-runtimes to dependencies

Add geometry methods for point, vector, and rectangle.

Ensure one type of test can only be handled at a time.

Implement tests for joystick axis, hat, and button events.

Order files from order of includes.

Add third-party mocks, specify mock files.

/? Do we need first-party mocks in their own files, or can we provide a
mock flag in the implementation files already?

Make device handling opt-in.

Include mocks and stubs implementation in config unit tests.

Use bdd-for-c for unit tests.

Extract config-related code to their own source files.

Ensure that initial loading of the config saves the values back to the
config file, in order to account for fallback values.

We use minIni to parse ini files instead of implementing our own. This
is useful for config modifiable by the user, such as controls.

However, we haven't implemented a fault-tolerant config that writes to
the config when the existing file is corrupted or non-existent. We will
have to define a "save" as soon as we have all values defined for our
in-memory config, regardless if we have retrieved the values
successfully or provided default hardcoded values.

Since we use an external dependency to manage our configs, the CMake
config must be modified and the source files included in the build. How
do we organize the dependencies from other Git repositories moving forward?

Make CMake load dependencies relative to project directory.