Create an file to contain logging systems.

Logging is useful because it allows tracking of game execution. In the
event of a crash during testing log files can be consulted to gain
insight into the state of the game before the crash.

A logging system is yet to be designed. The file added to the project
('src\log.c') will contain any implementation.
Declare a data-type that can be used for logging.

The type 'LOG' declared in 'src\log.c' is the type that will be used to
transport information about a log file between functions.

By making this a typedef declaration it allows for hidden changes later
on in development without invalidating future code.
Declare an interface that can be used with logs.

The simple interface declared here can be throught of as a wrapper for
the functions declared 'stdio.h'. Function names are almost verbatim to
the library functions.

Such an interface is not designed to be used directly. Instead the goal
of the functions is to format output before it is actually outputted.
Finalise the internal logging interface.

A simple modification of the function comments and declarations found in
'src\log.h'. This is important because the implementation should be able
to change with no external effects.

Where possible parameters are marked as constant to reduce the
possibility of rampant modification.

Functions are all given internal linkage to prevent their use outside
of the translation unit storing logging. A separate, visible interface
is planned to be built on top of this system; including systems for
filtering and extra formatting.

This set of functions is now fixed.
Implement a bare form of the logging system.

The function declarations for the internal logging system found in
'src\log.c' are now actual definitions.

The whole system is currently a simple wrapper for the system found in
'stdio.h'.

The next task will be to build a collection of visible functions that
can be used to print messages in a custom fashion at runtime.
Create a method for opening logging files.

Previously there was no available method opening logs. With the addition
of 'src\log.h' and modification of 'src\log.c' comes this ability.
Make 'l*open' open '*.log' files when logging.

Modify both 'lopen' and 'lreopen' so that the files they open have a
text editor file-extensions.

This is simply a minor change to make the end result easier to observe.
Remove a return statement from 'DestroyLog'.

'DestroyLog' is not declared to return a value and so this commit
removes the attempt the function makes to return the result of 'lclose'.
Create a method for printing messages to logs.

The function 'PrintLogMsg' can be used to print messages. The parameter
'verbosity' can be used for filtering. Internally the resulting argument
is compared to an internal global variable.

If the argument is less than or equal to the internal value then the
message is printed, else the message is ignored.
Fix a formatting issue found in 'vlprintf'.

The buffer created to be passed to 'vfprintf' within 'vlprintf' was not
actually passed. This meant that newlines weren't added to the ends of
messages leading to all output being placed on a single line.
Create a series of constants for verbosity.

A range of all possible unsigned integers is a fairly large range for
logging purpose. Commonly, a far smaller range is required.

Within 'src\log.h' is a list of constant integers that can be used to
track verbosity instead of arbitrary numbers.

The function still accepts an integer in the case that a user would
prefer to use a custom scale.
Merge the newly created logging system.

The project now has a system for outputting messages during runtime. This
system makes use of the functions and types found in 'stdio.h'.

The implementation can be thought of in two parts:

 - First the lower-level part that thinly wraps the input/output
   functions found in C's standard library. The section is responsible
   for making sure new logs are opened with a readable extension, and
   that messages are suffixed with a newline; and

 - Secondly the accessible part that takes care of higher-level ideas
   such as filtering, and formatting.

When a new log is needed it is opened using a call to 'CreateLog' found
in 'src\log.h'. This returns a log type that can be passed to
'PrintLogMsg' to print messages as required. When the log is finished
with a call to 'DestroyLog' closes the log.

 - Create an file to contain logging systems (05297ea).
 - Declare a data-type that can be used for logging (8209da7).
 - Declare an interface that can be used with logs (180933a).
 - Finalise the internal logging interface (7d89228).
 - Implement a bare form of the logging system (3dc7740).
 - Create a method for opening logging files (2bbe87e).
 - Make 'l*open' open '*.log' files when logging (1d1fb92).
 - Remove a return statement from 'DestroyLog' (132a22d).
 - Create a method for printing messages to logs (78b86f4).
 - Fix a formatting issue found in 'vlprintf' (045e536).
 - Create a series of constants for verbosity (b7eaabd).