Initial multiplayer work:
 - Connection handshake
 - Activated modules server is using
 - Using block mapping server is using
 - Relevant chunk replication
 - Testing code for sending messages

Currently all single player games are servers, and join game connects to localhost
Server changes to blocks are replicated to clients.
Added a touch of extra debugging to block changed messages.
Started adding the backbone for entity replication
Overhauled entity/prefab/component persistence to be more modular and start to support features needed for entity replication
 - Entities can now be persisted with or without ids
 - Can now provide a FieldSerializationCheck to determine whether individual fields should be serialized
 - EntityRefTypeHandler now can be switched between creating normal entity references, or network entity references
Added NetEntityRef, that works on network ids rather than entity ids (allows references to be maintained to entities that aren't currently replicated)
Added Replicate annotation to mark component fields for network replication
Initial implementation of entity replication (initial, update and removal)
Overhauled Component Metadata handling and began adding support for event metadata (to support event replication)
Initial implementation of event replication.
Added host game option to menu (currently give same menu as singleplayer game, but will start it as a server).
Changed join game menu option to open join game dialog.
Changed join game menu to persist through the centralised config.
Change StateLoading to have a constructor specifically for joining a server, and fixed some behaviour around this.
Added replication annotations to some components.
Changed dropped blocks to be replicated for testing.
Improved EntityRef toString() to report prefab if any.
Changed component system initialisation to allow late registration.
Some fixes for entity replication handling.
Added configuration to hold the player's name.
Numerous fixes to event and entity replication.
Removed inital chat code and replaced with an event based system.
Added a client info prefab, for player information replicated to all players.
Fixed dumpEntities command to dump all entities even if they are not set to be persisted.
Added a "local" client indicator to ClientComponent.
Fixed initialisation order on client so that prefabs are registered before received entities are processed.
Removed irrelevent scoping from message manager.
Switched logging implementation to logback.
Rejigged serialization handling to allow the creation of multiple EntitySystemLibraries, with type handlers customised for different situations (e.g. networking)
Removed EntityRefTypeHandler network ref hack, split out into separate type handler
Fixed a bug with the EntitySerializer's deserializeOnto - was removing all components
Removed LoadEntities step from client loading process - was wiping initially replicated entities
Cleaned up the network classes, moving more server/client specific handling into the Server/ClientPlayer classes
Basic network player character system implemented. Characters are now created on the server and linked to their clients. This enables linking player character movement to chunk relevance, and thus sending chunks to clients as they move around.
Players now have a mesh, mostly for testing purposes (can be seen in first person, which is bad)
Implemented client to server entity replication. The entites must still be created on the server, and the fields are only replicated from owners.
Implemented restricting which component systems are loaded based on network mode.
Implemented the ability to remove components from consideration by network serializers
LocationComponent now replicates position and rotation from the owner.
Input events are now sent to both to the local client, and that client's character.
Initial support for network metrics.
Fixed chunk cache region notification of chunks becoming available.
Clients can now see their inventory - items are replicated to their owners.
Removed GameType system, as it wasn't suitable for networking as is.
Started adding a net rate to limit replication per second
Fixed block items (apparently prefab inheritance only works for one level at the moment)
Implemented basic network support for UseItem and Attack
Added some support around block entity replication
Restricted client events to only be propagated when sent to owned entities
Some optimisation to network messages - replaced use of strings for component/event and field names with ids.
Added an improved format for entity data (PackedEntity).
Some general tweaks and fixes to the metadata system.
Changed net dirty state to be tracked per component.
Changed the replication mechanism of components, components now have to explicitly annotated to be replicated when added/removed, or contain a replicated field.
Changed a bunch of Multimap fields to correctly be SetMultimaps (as per guava usage recommendations)