Subatomic is a networked game project revolving around the utilization of REST, NodeJs, MongoDB, UDP, Qt, Google Protobuf, Python and Unity. The project itself is a combination of three individually purposed projects.
Subatomic Back-End
The first project is the Subatomic Back-end project. This utilizes a RESTful implementation through Nodejs where persistent data is stored in MongoDB. 
The server that hosts this implementation lives on a Digital Ocean droplet. The purpose of this project is to allow users to register their accounts to allow for logging back in or out, create in-game player characters as well as other future applications that aren’t yet implemented in this project. Such as saving inventory, last location in the world for particular player objects as well as other things relating to the state of the game world. The saving and retrieval of persistent data is the driving force for this project’s purpose within Subatomic.
The following gif represents the registration process, which sends a request to the Digital Ocean server for creating a new user that is stored in the MongoDB that can be logged in and out with during future sessions:
This gif represents the player ship creation process that stores within the MongoDB that can be used within the Subatomic game world, construction sends a request for storing the player ship in the player’s mongodb table:
The logging back in of the registered user is demonstrated in this gif, where they can utilize their created player ships, logging in sends a request to the back-end server for the player ship objects that the user created in prior sessions:
Subatomic Server
The second project is the Subatomic Server project. This is the heart of the project in terms of what allows for players to interact with each other. This provides simulation of various requested game events, packet sending, packet receiving, packet tracking, message logging and data tracking of the game world and connected clients. In addition, the sending, receiving and game simulation occur in separate threads to allow for continual data streaming and processing of their own purposes.
The following gif shows a demonstration of the Subatomic Server in-action:
This project is separated into three individual sub-projects within itself. Allowing for organization and separation of particular purpose. The project as a whole is wrapped around the Qt platform and compiled using mingw. The purpose for this choice has been to allow for a smoother transition to a Unix platform in the future.
Subatomic Protocol Buffers
The first sub-project is the Subatomic Protocol Buffers sub-project. This utilizes Google’s Protobuf API for generating message code that I send across the wire using UDP. Here is an example of my utilization of the .proto raw messages before they are regenerated into their corresponding .cpp, .h & .cs files:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Author : Chase Hutchens // Copyright (c) 2016 DigiPen (USA) Corporation. All rights reserved. syntax = "proto3"; package server.game; message CreateNetObject { string pid = 1; string spid = 2; bool isSnapshot = 3; enum Type { UNKNOWN = 0; PLAYER_PROJECTILE = 1; } Type type = 4; float xloc = 5; float yloc = 6; sint32 zrot = 7; } |
I store these messages in a ProtocolBuffers folder within their corresponding sub-folders. After a new message or modification of an older message I run a python script that recursively collects the .proto files, compiles them through Google Protobuf’s protoc.exe interpreter for output as .cpp & .h into this sub-project. These message are also outputted as .cs for utilization in the Subatomic Game Client Unity project. One of the coolest aspects of this iteration process is how quickly it is to add a new message or modify an existing message. From here this sub-project is compiled into a shared library for usage in the other Subatomic Server sub-projects.
Subatomic Server Lib
The second sub-project is the shared library where the generic server code is implemented. The features include:
- The implementation and concept of the server, client and client manager.
- Received message registration and threaded receiving & dispatching.
- Threaded sending of messages.
- Packet tracking implementation for making sure we keep trying to send messages that need acknowledgment.
- Client and Server logging to keep track of messages that have been sent and received.
- Custom command interface registration.
Subatomic Interface
The third sub-project is the particular implementation for the Subatomic Game and client interaction. Within here the Qt interface is created, implemented and utilized. Where custom Subatomic Server Lib interfaces are used to define the messages that are used for the Subatomic Game. Such as the custom definition for when a player has sent a ping to the Subatomic Server from within the Subatomic game, the PacketReceiveHandler is defined for that message:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
class PingReceiver : public PacketReceiveHandler { public: virtual void operator()(ServerObject* serverObject, const Manager::ClientPtr client, const base::BaseMessage& baseMsg) override { server::Ping pingPacket; baseMsg.msg().UnpackTo(&pingPacket); SubatomicConsole* console = static_cast<SubatomicConsole*>(serverObject->parent()); console->GetOGLStatsWidget()->AddPingSample( Manager::ClientKey(client->GetConnectId()), pingPacket.latency()); PacketDataPtr packetData = PacketData::GenerateMessagePacket(server::Pong()); GameLayer::GameWorldHandler::GetInstance().SendTo(client, packetData, serverObject); } }; |
Where these messages are registered to the PacketHandler:
|
1 |
REGISTER_RECEIVER(PingReceiver, "server.Ping"); |
The game world specific pieces are also simulated here to allow for the server side to maintain the core state of the world. Such as when a player requests to shoot a projectile, the server will create a projectile and simulate it’s location and determine if it collides with another game client.
Subatomic Game Client
The third project is the Subatomic Game Client Unity project. This has served mainly as my testing area during the development of the Subatomic Server and utilization of the Subatomic Back-End. The client communicates over the network with the back-end for persistent data storage, and through the Subatomic Server for game specific aspects. Such as telling the server about our Transform information, if we are shooting, connecting or disconnecting and other game related confirmations and messages.
This client utilizes Google Protobuf in the form of outputted c-sharp files for sending message definitions over UDP to the Subatomic Server. The awesome bit here is the interchangeability of being able to write a custom .proto file and having it be outputted as both .cpp, .h & .cs for utilization on whichever end. This is how I’m sending these protobuf messages on the c-sharp side:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
static public Base.BaseMessage GenerateMessage<T>(Google.Protobuf.IMessage<T> toSend, bool trackPacket = false) where T : Google.Protobuf.IMessage<T> { Base.BaseMessage msg = new Base.BaseMessage(); msg.Msg = Google.Protobuf.WellKnownTypes.Any.Pack(toSend, "Subatomic"); msg.Size = (uint)msg.CalculateSize(); if (trackPacket) { msg.Track = true; msg.PacketId = PacketTracker.TrackPacket(new PacketTracker.PacketTrackData(msg)); } SendNetMessage(msg); return msg; } static public void SendNetMessage(Base.BaseMessage msg) { UnitySingletonPersistent<ServerSender>.Instance.DataToSend(msg); ConsoleBehavior console = UnitySingletonPersistent<ClientObject>.Instance.m_console; if (console != null) { string logMsg = "<color=cyan>" + msg.ToString() + "</color>"; console.AddLine(logMsg); } } |
The game client admittedly still leaves a lot to be desired. My goal for the future is to re-work the game client to revolve around a more three dimensional world of collaboration which will allow for uncovering and solving new problems both server and client side.