Merge branch 'login' (read more)

Made a few tweaks to the code, but the build still works, so I'm merging it into master.

client/client_application.cpp

@@ -21,15 +21,11 @@
 */
 #include "client_application.hpp"
 
+#include "serial.hpp"
+
 #include <stdexcept>
 #include <chrono>
 
-//-------------------------
-//Static declarations
-//-------------------------
-
-ClientApplication ClientApplication::instance;
-
 //-------------------------
 //Scene headers
 //-------------------------
@@ -46,15 +42,7 @@ ClientApplication ClientApplication::instance;
 //Public access members
 //-------------------------
 
-ClientApplication::ClientApplication() {
-	//
-}
-
-ClientApplication::~ClientApplication() {
-	//
-}
-
-void ClientApplication::Init() {
+void ClientApplication::Init(int argc, char** argv) {
 	//load the prerequisites
 	config.Load("rsc\\config.cfg");
 

client/client_application.hpp

@@ -26,19 +26,14 @@
 #include "base_scene.hpp"
 
 #include "config_utility.hpp"
-#include "network_packet.hpp"
 #include "udp_network_utility.hpp"
 
 class ClientApplication {
-private:
-	ClientApplication();
-	~ClientApplication();
-	static ClientApplication instance;
-
 public:
-	static ClientApplication* GetInstance() { return &instance; }
+	ClientApplication() = default;
+	~ClientApplication() = default;
 
-	void Init();
+	void Init(int argc, char** argv);
 	void Proc();
 	void Quit();
 

client/main.cpp

@@ -26,12 +26,13 @@
 
 using namespace std;
 
-int main(int, char**) {
+int main(int argc, char** argv) {
 	cout << "Beginning client" << endl;
 	try {
-		ClientApplication::GetInstance()->Init();
-		ClientApplication::GetInstance()->Proc();
-		ClientApplication::GetInstance()->Quit();
+		ClientApplication app;
+		app.Init(argc, argv);
+		app.Proc();
+		app.Quit();
 	}
 	catch(exception& e) {
 		cerr << "Fatal exception thrown: " << e.what() << endl;

client/scenes/in_world.cpp

@@ -63,8 +63,8 @@ InWorld::InWorld(ConfigUtility* const argConfig, UDPNetworkUtility* const argNet
 
 	//create the server-side player object
 	//TODO: the login system needs an overhaul
-	NetworkPacket packet;
-	packet.meta.type = NetworkPacket::Type::PLAYER_NEW;
+	SerialPacket packet;
+	packet.meta.type = SerialPacket::Type::PLAYER_NEW;
 	packet.playerInfo.clientIndex = clientIndex;
 	snprintf(packet.playerInfo.handle, PACKET_STRING_SIZE, "%s", config["player.handle"].c_str());
 	snprintf(packet.playerInfo.avatar, PACKET_STRING_SIZE, "%s", config["player.avatar"].c_str());
@@ -77,7 +77,7 @@ InWorld::InWorld(ConfigUtility* const argConfig, UDPNetworkUtility* const argNet
 	network.Send(Channels::SERVER, buffer, PACKET_BUFFER_SIZE);
 
 	//request a sync
-	packet.meta.type = NetworkPacket::Type::SYNCHRONIZE;
+	packet.meta.type = SerialPacket::Type::SYNCHRONIZE;
 	serialize(&packet, buffer);
 	network.Send(Channels::SERVER, buffer, PACKET_BUFFER_SIZE);
 
@@ -98,7 +98,7 @@ void InWorld::FrameStart() {
 }
 
 void InWorld::Update(double delta) {
-	NetworkPacket packet;
+	SerialPacket packet;
 
 	//suck in all waiting packets
 	while(network.Receive()) {
@@ -257,37 +257,37 @@ void InWorld::KeyUp(SDL_KeyboardEvent const& key) {
 //Network handlers
 //-------------------------
 
-void InWorld::HandlePacket(NetworkPacket packet) {
+void InWorld::HandlePacket(SerialPacket packet) {
 	switch(packet.meta.type) {
-		case NetworkPacket::Type::DISCONNECT:
+		case SerialPacket::Type::DISCONNECT:
 			HandleDisconnect(packet);
 		break;
-		case NetworkPacket::Type::PLAYER_NEW:
+		case SerialPacket::Type::PLAYER_NEW:
 			HandlePlayerNew(packet);
 		break;
-		case NetworkPacket::Type::PLAYER_DELETE:
+		case SerialPacket::Type::PLAYER_DELETE:
 			HandlePlayerDelete(packet);
 		break;
-		case NetworkPacket::Type::PLAYER_UPDATE:
+		case SerialPacket::Type::PLAYER_UPDATE:
 			HandlePlayerUpdate(packet);
 		break;
-		case NetworkPacket::Type::REGION_CONTENT:
+		case SerialPacket::Type::REGION_CONTENT:
 			HandleRegionContent(packet);
 		break;
 		//handle errors
 		default:
-			throw(std::runtime_error("Unknown NetworkPacket::Type encountered"));
+			throw(std::runtime_error("Unknown SerialPacket::Type encountered"));
 		break;
 	}
 }
 
-void InWorld::HandleDisconnect(NetworkPacket packet) {
+void InWorld::HandleDisconnect(SerialPacket packet) {
 	network.Unbind(Channels::SERVER);
 	clientIndex = -1;
 	SetNextScene(SceneList::MAINMENU);
 }
 
-void InWorld::HandlePlayerNew(NetworkPacket packet) {
+void InWorld::HandlePlayerNew(SerialPacket packet) {
 	if (playerCharacters.find(packet.playerInfo.playerIndex) != playerCharacters.end()) {
 		throw(std::runtime_error("Cannot create duplicate players"));
 	}
@@ -310,7 +310,7 @@ void InWorld::HandlePlayerNew(NetworkPacket packet) {
 	}
 }
 
-void InWorld::HandlePlayerDelete(NetworkPacket packet) {
+void InWorld::HandlePlayerDelete(SerialPacket packet) {
 	if (playerCharacters.find(packet.playerInfo.playerIndex) == playerCharacters.end()) {
 		throw(std::runtime_error("Cannot delete non-existant players"));
 	}
@@ -324,7 +324,7 @@ void InWorld::HandlePlayerDelete(NetworkPacket packet) {
 	}
 }
 
-void InWorld::HandlePlayerUpdate(NetworkPacket packet) {
+void InWorld::HandlePlayerUpdate(SerialPacket packet) {
 	if (playerCharacters.find(packet.playerInfo.playerIndex) == playerCharacters.end()) {
 		HandlePlayerNew(packet);
 		return;
@@ -338,7 +338,7 @@ void InWorld::HandlePlayerUpdate(NetworkPacket packet) {
 	playerCharacters[packet.playerInfo.playerIndex].ResetDirection();
 }
 
-void InWorld::HandleRegionContent(NetworkPacket packet) {
+void InWorld::HandleRegionContent(SerialPacket packet) {
 	//replace existing regions
 	if (regionPager.FindRegion(packet.regionInfo.x, packet.regionInfo.y)) {
 		regionPager.UnloadRegion(packet.regionInfo.x, packet.regionInfo.y);
@@ -352,11 +352,11 @@ void InWorld::HandleRegionContent(NetworkPacket packet) {
 //-------------------------
 
 void InWorld::SendState() {
-	NetworkPacket packet;
+	SerialPacket packet;
 	char buffer[PACKET_BUFFER_SIZE];
 
 	//pack the packet
-	packet.meta.type = NetworkPacket::Type::PLAYER_UPDATE;
+	packet.meta.type = SerialPacket::Type::PLAYER_UPDATE;
 	packet.playerInfo.clientIndex = clientIndex;
 	packet.playerInfo.playerIndex = playerIndex;
 	packet.playerInfo.position = localCharacter->GetPosition();
@@ -367,33 +367,33 @@ void InWorld::SendState() {
 }
 
 void InWorld::RequestDisconnect() {
-	NetworkPacket packet;
+	SerialPacket packet;
 	char buffer[PACKET_BUFFER_SIZE];
 
 	//send a disconnect request
-	packet.meta.type = NetworkPacket::Type::DISCONNECT;
+	packet.meta.type = SerialPacket::Type::DISCONNECT;
 	packet.clientInfo.index = clientIndex;
 	serialize(&packet, buffer);
 	network.Send(Channels::SERVER, buffer, PACKET_BUFFER_SIZE);
 }
 
 void InWorld::RequestShutDown() {
-	NetworkPacket packet;
+	SerialPacket packet;
 	char buffer[PACKET_BUFFER_SIZE];
 
 	//send a shutdown request
-	packet.meta.type = NetworkPacket::Type::SHUTDOWN;
+	packet.meta.type = SerialPacket::Type::SHUTDOWN;
 	packet.clientInfo.index = clientIndex;
 	serialize(&packet, buffer);
 	network.Send(Channels::SERVER, buffer, PACKET_BUFFER_SIZE);
 }
 
 void InWorld::RequestRegion(int x, int y) {
-	NetworkPacket packet;
+	SerialPacket packet;
 	char buffer[PACKET_BUFFER_SIZE];
 
 	//pack the region's data
-	packet.meta.type = NetworkPacket::Type::REGION_REQUEST;
+	packet.meta.type = SerialPacket::Type::REGION_REQUEST;
 	packet.regionInfo.x = x;
 	packet.regionInfo.y = y;
 	serialize(&packet, buffer);

client/scenes/in_world.hpp

@@ -29,7 +29,7 @@
 
 //networking
 #include "udp_network_utility.hpp"
-#include "network_packet.hpp"
+#include "serial_packet.hpp"
 #include "serial.hpp"
 
 //graphics
@@ -72,12 +72,12 @@ protected:
 	void KeyUp(SDL_KeyboardEvent const&);
 
 	//Network handlers
-	void HandlePacket(NetworkPacket);
-	void HandleDisconnect(NetworkPacket);
-	void HandlePlayerNew(NetworkPacket);
-	void HandlePlayerDelete(NetworkPacket);
-	void HandlePlayerUpdate(NetworkPacket);
-	void HandleRegionContent(NetworkPacket);
+	void HandlePacket(SerialPacket);
+	void HandleDisconnect(SerialPacket);
+	void HandlePlayerNew(SerialPacket);
+	void HandlePlayerDelete(SerialPacket);
+	void HandlePlayerUpdate(SerialPacket);
+	void HandleRegionContent(SerialPacket);
 
 	//Server control
 	void SendState();

client/scenes/lobby_menu.cpp

@@ -78,7 +78,7 @@ void LobbyMenu::FrameStart() {
 
 void LobbyMenu::Update(double delta) {
 	//suck in all waiting packets
-	NetworkPacket packet;
+	SerialPacket packet;
 	while(network.Receive()) {
 		deserialize(&packet, network.GetInData());
 		packet.meta.srcAddress = network.GetInPacket()->address;
@@ -126,11 +126,11 @@ void LobbyMenu::MouseButtonDown(SDL_MouseButtonEvent const& button) {
 void LobbyMenu::MouseButtonUp(SDL_MouseButtonEvent const& button) {
 	if (search.MouseButtonUp(button) == Button::State::HOVER) {
 		//the vars
-		NetworkPacket packet;
+		SerialPacket packet;
 		char buffer[PACKET_BUFFER_SIZE];
 
 		//broadcast to the network, or a specific server
-		packet.meta.type = NetworkPacket::Type::BROADCAST_REQUEST;
+		packet.meta.type = SerialPacket::Type::BROADCAST_REQUEST;
 		serialize(&packet, buffer);
 		network.Send(config["server.host"].c_str(), config.Int("server.port"), buffer, PACKET_BUFFER_SIZE);
 
@@ -141,11 +141,11 @@ void LobbyMenu::MouseButtonUp(SDL_MouseButtonEvent const& button) {
 
 	else if (join.MouseButtonUp(button) == Button::State::HOVER && selection != nullptr) {
 		//the vars
-		NetworkPacket packet;
+		SerialPacket packet;
 		char buffer[PACKET_BUFFER_SIZE];
 
 		//join the selected server
-		packet.meta.type = NetworkPacket::Type::JOIN_REQUEST;
+		packet.meta.type = SerialPacket::Type::JOIN_REQUEST;
 		serialize(&packet, buffer);
 		network.Send(&selection->address, buffer, PACKET_BUFFER_SIZE);
 		selection = nullptr;
@@ -181,16 +181,16 @@ void LobbyMenu::KeyUp(SDL_KeyboardEvent const& key) {
 	//
 }
 
-void LobbyMenu::HandlePacket(NetworkPacket packet) {
+void LobbyMenu::HandlePacket(SerialPacket packet) {
 		switch(packet.meta.type) {
-		case NetworkPacket::Type::BROADCAST_RESPONSE: {
+		case SerialPacket::Type::BROADCAST_RESPONSE: {
 			ServerInformation server;
 			server.name = packet.serverInfo.name;
 			server.address = packet.meta.srcAddress;
 			serverInfo.push_back(server);
 		}
 		break;
-		case NetworkPacket::Type::JOIN_RESPONSE:
+		case SerialPacket::Type::JOIN_RESPONSE:
 			clientIndex = packet.clientInfo.index;
 			network.Bind(&packet.meta.srcAddress, Channels::SERVER);
 			SetNextScene(SceneList::INWORLD);
@@ -198,7 +198,7 @@ void LobbyMenu::HandlePacket(NetworkPacket packet) {
 
 		//handle errors
 		default:
-			throw(std::runtime_error("Unknown NetworkPacket::Type encountered"));
+			throw(std::runtime_error("Unknown SerialPacket::Type encountered"));
 		break;
 	}
 }

client/scenes/lobby_menu.hpp

@@ -30,7 +30,7 @@
 
 #include "config_utility.hpp"
 #include "udp_network_utility.hpp"
-#include "network_packet.hpp"
+#include "serial_packet.hpp"
 #include "serial.hpp"
 
 #include <vector>
@@ -55,7 +55,7 @@ protected:
 	void KeyDown(SDL_KeyboardEvent const&);
 	void KeyUp(SDL_KeyboardEvent const&);
 
-	void HandlePacket(NetworkPacket);
+	void HandlePacket(SerialPacket);
 
 	//global
 	ConfigUtility& config;

common/network/serial.cpp

@@ -29,25 +29,25 @@
 //internal serialization functions
 //-------------------------
 
-void serializeType(NetworkPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(NetworkPacket::Type));
+void serializeType(SerialPacket* packet, char* buffer) {
+	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
 }
 
-void serializeServer(NetworkPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void serializeServer(SerialPacket* packet, char* buffer) {
+	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 	memcpy(buffer, packet->serverInfo.name, PACKET_STRING_SIZE);
 }
 
-void serializeClient(NetworkPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void serializeClient(SerialPacket* packet, char* buffer) {
+	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 	memcpy(buffer, &packet->clientInfo.index, sizeof(int));
 }
 
-void serializePlayer(NetworkPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void serializePlayer(SerialPacket* packet, char* buffer) {
+	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 
 	//indexes
 	memcpy(buffer, &packet->playerInfo.clientIndex, sizeof(int));
@@ -71,9 +71,9 @@ void serializePlayer(NetworkPacket* packet, char* buffer) {
 	memcpy(buffer, &packet->playerInfo.motion.y, sizeof(double));
 }
 
-void serializeRegionFormat(NetworkPacket* packet, char* buffer) {
-	memcpy(buffer, &packet->meta.type, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void serializeRegionFormat(SerialPacket* packet, char* buffer) {
+	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 
 	//x & y
 	memcpy(buffer, &packet->regionInfo.x, sizeof(int));
@@ -81,10 +81,10 @@ void serializeRegionFormat(NetworkPacket* packet, char* buffer) {
 	memcpy(buffer, &packet->regionInfo.y, sizeof(int));
 }
 
-void serializeRegionContent(NetworkPacket* packet, char* buffer) {
+void serializeRegionContent(SerialPacket* packet, char* buffer) {
 	//format
-	memcpy(buffer, &packet->meta.type, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+	memcpy(buffer, &packet->meta.type, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 
 	//x & y
 	*reinterpret_cast<int*>(buffer) = packet->regionInfo.region->GetX();
@@ -107,25 +107,25 @@ void serializeRegionContent(NetworkPacket* packet, char* buffer) {
 //internal deserialization functions
 //-------------------------
 
-void deserializeType(NetworkPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(NetworkPacket::Type));
+void deserializeType(SerialPacket* packet, char* buffer) {
+	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
 }
 
-void deserializeServer(NetworkPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void deserializeServer(SerialPacket* packet, char* buffer) {
+	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 	memcpy(packet->serverInfo.name, buffer, PACKET_STRING_SIZE);
 }
 
-void deserializeClient(NetworkPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void deserializeClient(SerialPacket* packet, char* buffer) {
+	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 	memcpy(&packet->clientInfo.index, buffer, sizeof(int));
 }
 
-void deserializePlayer(NetworkPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void deserializePlayer(SerialPacket* packet, char* buffer) {
+	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 
 	//indexes
 	memcpy(&packet->playerInfo.clientIndex, buffer, sizeof(int));
@@ -149,9 +149,9 @@ void deserializePlayer(NetworkPacket* packet, char* buffer) {
 	memcpy(&packet->playerInfo.motion.y, buffer, sizeof(double));
 }
 
-void deserializeRegionFormat(NetworkPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void deserializeRegionFormat(SerialPacket* packet, char* buffer) {
+	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 
 	//x & y
 	memcpy(&packet->regionInfo.x, buffer, sizeof(int));
@@ -159,9 +159,9 @@ void deserializeRegionFormat(NetworkPacket* packet, char* buffer) {
 	memcpy(&packet->regionInfo.y, buffer, sizeof(int));
 }
 
-void deserializeRegionContent(NetworkPacket* packet, char* buffer) {
-	memcpy(&packet->meta.type, buffer, sizeof(NetworkPacket::Type));
-	buffer += sizeof(NetworkPacket::Type);
+void deserializeRegionContent(SerialPacket* packet, char* buffer) {
+	memcpy(&packet->meta.type, buffer, sizeof(SerialPacket::Type));
+	buffer += sizeof(SerialPacket::Type);
 
 	//x & y
 	memcpy(&packet->regionInfo.x, buffer, sizeof(int));
@@ -190,87 +190,87 @@ void deserializeRegionContent(NetworkPacket* packet, char* buffer) {
 //the interface functions
 //-------------------------
 
-void serialize(NetworkPacket* packet, void* buffer) {
+void serialize(SerialPacket* packet, void* buffer) {
 	switch(packet->meta.type) {
 		//No extra data
-		case NetworkPacket::Type::NONE:
-		case NetworkPacket::Type::PING:
-		case NetworkPacket::Type::PONG:
-		case NetworkPacket::Type::BROADCAST_REQUEST:
-		case NetworkPacket::Type::JOIN_REQUEST:
-		case NetworkPacket::Type::SYNCHRONIZE:
+		case SerialPacket::Type::NONE:
+		case SerialPacket::Type::PING:
+		case SerialPacket::Type::PONG:
+		case SerialPacket::Type::BROADCAST_REQUEST:
+		case SerialPacket::Type::JOIN_REQUEST:
+		case SerialPacket::Type::SYNCHRONIZE:
 			serializeType(packet, reinterpret_cast<char*>(buffer));
 		break;
 
 		//Server info
-		case NetworkPacket::Type::BROADCAST_RESPONSE:
+		case SerialPacket::Type::BROADCAST_RESPONSE:
 			serializeServer(packet, reinterpret_cast<char*>(buffer));
 		break;
 
 		//Client info
-		case NetworkPacket::Type::JOIN_RESPONSE:
-		case NetworkPacket::Type::DISCONNECT:
-		case NetworkPacket::Type::SHUTDOWN:
+		case SerialPacket::Type::JOIN_RESPONSE:
+		case SerialPacket::Type::DISCONNECT:
+		case SerialPacket::Type::SHUTDOWN:
 			serializeClient(packet, reinterpret_cast<char*>(buffer));
 		break;
 
 		//Player info
-		case NetworkPacket::Type::PLAYER_NEW:
-		case NetworkPacket::Type::PLAYER_DELETE:
-		case NetworkPacket::Type::PLAYER_UPDATE:
+		case SerialPacket::Type::PLAYER_NEW:
+		case SerialPacket::Type::PLAYER_DELETE:
+		case SerialPacket::Type::PLAYER_UPDATE:
 			serializePlayer(packet, reinterpret_cast<char*>(buffer));
 		break;
 
 		//region info
-		case NetworkPacket::Type::REGION_REQUEST:
+		case SerialPacket::Type::REGION_REQUEST:
 			serializeRegionFormat(packet, reinterpret_cast<char*>(buffer));
 		break;
 
-		case NetworkPacket::Type::REGION_CONTENT:
+		case SerialPacket::Type::REGION_CONTENT:
 			serializeRegionContent(packet, reinterpret_cast<char*>(buffer));
 		break;
 	}
 }
 
-void deserialize(NetworkPacket* packet, void* buffer) {
+void deserialize(SerialPacket* packet, void* buffer) {
 	//find the type, so that you can actually deserialize the packet!
 	deserializeType(packet, reinterpret_cast<char*>(buffer));
 	switch(packet->meta.type) {
 		//No extra data
-		case NetworkPacket::Type::NONE:
-		case NetworkPacket::Type::PING:
-		case NetworkPacket::Type::PONG:
-		case NetworkPacket::Type::BROADCAST_REQUEST:
-		case NetworkPacket::Type::JOIN_REQUEST:
-		case NetworkPacket::Type::SYNCHRONIZE:
+		case SerialPacket::Type::NONE:
+		case SerialPacket::Type::PING:
+		case SerialPacket::Type::PONG:
+		case SerialPacket::Type::BROADCAST_REQUEST:
+		case SerialPacket::Type::JOIN_REQUEST:
+		case SerialPacket::Type::SYNCHRONIZE:
 			//NOTHING
 		break;
 
 		//Server info
-		case NetworkPacket::Type::BROADCAST_RESPONSE:
+		case SerialPacket::Type::BROADCAST_RESPONSE:
 			deserializeServer(packet, reinterpret_cast<char*>(buffer));
 		break;
 
 		//Client info
-		case NetworkPacket::Type::JOIN_RESPONSE:
-		case NetworkPacket::Type::DISCONNECT:
-		case NetworkPacket::Type::SHUTDOWN:
+		case SerialPacket::Type::JOIN_RESPONSE:
+		case SerialPacket::Type::DISCONNECT:
+		case SerialPacket::Type::SHUTDOWN:
 			deserializeClient(packet, reinterpret_cast<char*>(buffer));
 		break;
 
 		//Player info
-		case NetworkPacket::Type::PLAYER_NEW:
-		case NetworkPacket::Type::PLAYER_DELETE:
-		case NetworkPacket::Type::PLAYER_UPDATE:
+		case SerialPacket::Type::PLAYER_NEW:
+		case SerialPacket::Type::PLAYER_DELETE:
+		case SerialPacket::Type::PLAYER_UPDATE:
 			deserializePlayer(packet, reinterpret_cast<char*>(buffer));
 		break;
 
 		//region info
-		case NetworkPacket::Type::REGION_REQUEST:
+		case SerialPacket::Type::REGION_REQUEST:
 			deserializeRegionFormat(packet, reinterpret_cast<char*>(buffer));
 		break;
 
-		case NetworkPacket::Type::REGION_CONTENT:
+		case SerialPacket::Type::REGION_CONTENT:
 			deserializeRegionContent(packet, reinterpret_cast<char*>(buffer));
 		break;
 	}

common/network/serial.hpp

@@ -22,7 +22,7 @@
 #ifndef SERIAL_HPP_
 #define SERIAL_HPP_
 
-#include "network_packet.hpp"
+#include "serial_packet.hpp"
 
 /* TODO: Keep the PACKET_BUFFER_SIZE up to date
  * NOTE: REGION_CONTENT is currently the largest type of packet
@@ -30,9 +30,9 @@
  *  map format: sizeof(int) * 2
  *  metadata: sizeof(metadata)
 */
-#define PACKET_BUFFER_SIZE REGION_WIDTH * REGION_HEIGHT * REGION_DEPTH * sizeof(Region::type_t) + sizeof(int) * 2 + sizeof(NetworkPacket::Metadata)
+#define PACKET_BUFFER_SIZE REGION_WIDTH * REGION_HEIGHT * REGION_DEPTH * sizeof(Region::type_t) + sizeof(int) * 2 + sizeof(SerialPacket::Metadata)
 
-void serialize(NetworkPacket* const, void*);
-void deserialize(NetworkPacket* const, void*);
+void serialize(SerialPacket* const, void*);
+void deserialize(SerialPacket* const, void*);
 
 #endif

common/network/serial_packet.hpp

@@ -19,8 +19,8 @@
  * 3. This notice may not be removed or altered from any source
  * distribution.
 */
-#ifndef NETWORKPACKET_HPP_
-#define NETWORKPACKET_HPP_
+#ifndef SERIALPACKET_HPP_
+#define SERIALPACKET_HPP_
 
 #include "vector2.hpp"
 #include "region.hpp"
@@ -31,8 +31,7 @@
 
 #pragma pack(push, 0)
 
-//TODO: rename to serial packet
-union NetworkPacket {
+union SerialPacket {
 	//types of packets
 	enum class Type {
 		//default: there is something wrong
@@ -112,7 +111,7 @@ union NetworkPacket {
 	}regionInfo;
 
 	//defaults
-	NetworkPacket() {
+	SerialPacket() {
 		meta.type = Type::NONE;
 		meta.srcAddress = {0,0};
 	}

editor/editor_application.cpp

@@ -24,12 +24,6 @@
 #include <stdexcept>
 #include <chrono>
 
-//-------------------------
-//Static declarations
-//-------------------------
-
-EditorApplication EditorApplication::instance;
-
 //-------------------------
 //Scene headers
 //-------------------------
@@ -42,15 +36,7 @@ EditorApplication EditorApplication::instance;
 //Public access members
 //-------------------------
 
-EditorApplication::EditorApplication() {
-	//
-}
-
-EditorApplication::~EditorApplication() {
-	//
-}
-
-void EditorApplication::Init() {
+void EditorApplication::Init(int argc, char** argv) {
 	config.Load("rsc\\config.cfg");
 	if (SDL_Init(SDL_INIT_VIDEO))
 		throw(std::runtime_error("Failed to initialize SDL"));

editor/editor_application.hpp

@@ -27,15 +27,11 @@
 #include "config_utility.hpp"
 
 class EditorApplication {
-private:
-	EditorApplication();
-	~EditorApplication();
-	static EditorApplication instance;
-
 public:
-	static EditorApplication* GetInstance() { return &instance; }
+	EditorApplication() = default;
+	~EditorApplication() = default;
 
-	void Init();
+	void Init(int argc, char** argv);
 	void Proc();
 	void Quit();
 

editor/main.cpp

@@ -26,12 +26,13 @@
 
 using namespace std;
 
-int main(int, char**) {
+int main(int argc, char** argv) {
 	cout << "Beginning editor" << endl;
 	try {
-		EditorApplication::GetInstance()->Init();
-		EditorApplication::GetInstance()->Proc();
-		EditorApplication::GetInstance()->Quit();
+		EditorApplication app;
+		app.Init(argc, argv);
+		app.Proc();
+		app.Quit();
 	}
 	catch(exception& e) {
 		cerr << "Fatal exception thrown: " << e.what() << endl;

makefile

@@ -1,3 +1,4 @@
+#TODO: The build process needs revising
 #for use on Windows:
 
 #MKDIR=mkdir

rsc/scripts/setup_server.sql

@@ -1,11 +1,13 @@
+--TODO: The SQL startup script needs revising
+
 -------------------------
 --Server
 -------------------------
 
 CREATE TABLE IF NOT EXISTS UserAccounts (
-	userAccountID INTEGER PRIMARY KEY AUTOINCREMENT,
-	username varchar(30) UNIQUE,
-	password varchar(30),
+	uid INTEGER PRIMARY KEY AUTOINCREMENT,
+	username varchar(100) UNIQUE,
+	password varchar(100), --NOTE: DO NOT DO THIS!!
 	blacklisted BIT DEFAULT 0,
 	whitelisted BIT DEFAULT 1
 );
@@ -14,31 +16,30 @@ CREATE TABLE IF NOT EXISTS UserAccounts (
 --Items
 -------------------------
 
-CREATE TABLE IF NOT EXISTS GlobalItemList (
-	globalItemListID INTEGER PRIMARY KEY AUTOINCREMENT,
-	itemName varchar(30) UNIQUE,
-	itemImage varchar(30),
-	type varchar(15), --{'mundane', 'consumable', 'equipment'}
-	maxStackSize INTEGER, --{1-max; 0 for non-stackable}
-	maxUniqueCopies INTEGER --{1-max; 0 for unlimited}
-);
-
 CREATE TABLE IF NOT EXISTS MundaneItems (
-	mundaneItemID INTEGER PRIMARY KEY AUTOINCREMENT,
-	globalItemListID INTEGER REFERENCES GlobalItemList(globalItemListID)
-	--holds whatever
+	--metadata
+	uid INTEGER PRIMARY KEY AUTOINCREMENT,
+	itemID INTEGER,
+	stackSize INTEGER DEFAULT 0,
+	owner INTEGER REFERENCES PlayerCharacters(uid)
 );
 
 CREATE TABLE IF NOT EXISTS Consumables (
-	consumableID INTEGER PRIMARY KEY AUTOINCREMENT,
-	globalItemListID INTEGER REFERENCES GlobalItemList(globalItemListID)
+	--metadata
+	uid INTEGER PRIMARY KEY AUTOINCREMENT,
+	itemID INTEGER,
+	stackSize INTEGER DEFAULT 0,
+	owner INTEGER REFERENCES PlayerCharacters(uid)
 	--holds all consumable items info (food, potions, etc.)
 );
 
 CREATE TABLE IF NOT EXISTS Equipment (
-	equipmentID INTEGER PRIMARY KEY AUTOINCREMENT,
-	globalItemListID INTEGER REFERENCES GlobalItemList(globalItemListID)
+	--metadata
+	uid INTEGER PRIMARY KEY AUTOINCREMENT,
+	itemID INTEGER,
+	owner INTEGER REFERENCES PlayerCharacters(uid)
 	--hold all equipment info
+	--stat mods, special effects, etc.
 );
 
 -------------------------
@@ -46,28 +47,36 @@ CREATE TABLE IF NOT EXISTS Equipment (
 -------------------------
 
 CREATE TABLE IF NOT EXISTS PlayerCharacters (
-	playerCharacterID INTEGER PRIMARY KEY AUTOINCREMENT,
-	name varchar(30) UNIQUE,
+	uid INTEGER PRIMARY KEY AUTOINCREMENT,
 
-	--stats
-	currentLevel		INTEGER DEFAULT 0,
-	currentExperience	INTEGER DEFAULT 0,
-	maxHealth			INTEGER DEFAULT 0,
-	maxMana				INTEGER DEFAULT 0,
-	currentHealth		INTEGER DEFAULT 0,
-	currentMana			INTEGER DEFAULT 0,
+	--metadata
+	handle varchar(100) UNIQUE,
+	avatar varchar(100),
+	birth timestamp NOT NULL DEFAULT (datetime()),
+
+	--position
+	mapIndex		INTEGER DEFAULT 0,
+	positionX		INTEGER DEFAULT 0,
+	positionY		INTEGER DEFAULT 0,
+
+	--statistics
+	level			INTEGER DEFAULT 0,
+	exp				INTEGER DEFAULT 0,
+	maxHP			INTEGER DEFAULT 0,
+	health			INTEGER DEFAULT 0,
+	maxMP			INTEGER DEFAULT 0,
+	mana			INTEGER DEFAULT 0,
 	attack			INTEGER DEFAULT 0,
 	defence			INTEGER DEFAULT 0,
-	--etc.
+	intelligence	INTEGER DEFAULT 0,
+	resistance		INTEGER DEFAULT 0,
+	accuracy		REAL DEFAULT 0.0,
+	evasion			REAL DEFAULT 0.0,
+	luck			REAL DEFAULT 0.0,
 
 	--equipment
-	weapon INTEGER REFERENCES Equipment(equipmentID),
-	helmet INTEGER REFERENCES Equipment(equipmentID),
-	armour INTEGER REFERENCES Equipment(equipmentID)
+	weapon INTEGER REFERENCES Equipment(uid),
+	helmet INTEGER REFERENCES Equipment(uid),
+	armour INTEGER REFERENCES Equipment(uid)
 	--etc.
 );
-
-CREATE TABLE IF NOT EXISTS PlayerInventoryItems (
-	characterID INTEGER REFERENCES PlayerCharacters(characterID),
-	globalItemListID INTEGER REFERENCES GlobalItemList(globalItemListID)
-);

server/main.cpp

@@ -33,7 +33,7 @@ int main(int argc, char** argv) {
 	try {
 		ServerApplication app;
 		app.Init(argc, argv);
-		app.Loop();
+		app.Proc();
 		app.Quit();
 	}
 	catch(exception& e) {

server/server_application.cpp

@@ -87,7 +87,7 @@ void ServerApplication::Init(int argc, char** argv) {
 	regionPager.GetFormat()->SetSaveDir("save/mapname/");
 
 	std::cout << "Initialized the map system" << std::endl;
-	std::cout << "\tsizeof(NetworkPacket): " << sizeof(NetworkPacket) << std::endl;
+	std::cout << "\tsizeof(SerialPacket): " << sizeof(SerialPacket) << std::endl;
 	std::cout << "\tPACKET_BUFFER_SIZE: " << PACKET_BUFFER_SIZE << std::endl;
 
 	//finalize the startup
@@ -97,8 +97,8 @@ void ServerApplication::Init(int argc, char** argv) {
 	//
 }
 
-void ServerApplication::Loop() {
-	NetworkPacket packet;
+void ServerApplication::Proc() {
+	SerialPacket packet;
 	while(running) {
 		//suck in the waiting packets & process them
 		while(network.Receive()) {
@@ -133,38 +133,38 @@ void ServerApplication::Quit() {
 //Define the uber switch
 //-------------------------
 
-void ServerApplication::HandlePacket(NetworkPacket packet) {
+void ServerApplication::HandlePacket(SerialPacket packet) {
 	switch(packet.meta.type) {
-		case NetworkPacket::Type::BROADCAST_REQUEST:
+		case SerialPacket::Type::BROADCAST_REQUEST:
 			HandleBroadcastRequest(packet);
 		break;
-		case NetworkPacket::Type::JOIN_REQUEST:
+		case SerialPacket::Type::JOIN_REQUEST:
 			HandleJoinRequest(packet);
 		break;
-		case NetworkPacket::Type::DISCONNECT:
+		case SerialPacket::Type::DISCONNECT:
 			HandleDisconnect(packet);
 		break;
-		case NetworkPacket::Type::SYNCHRONIZE:
+		case SerialPacket::Type::SYNCHRONIZE:
 			HandleSynchronize(packet);
 		break;
-		case NetworkPacket::Type::SHUTDOWN:
+		case SerialPacket::Type::SHUTDOWN:
 			HandleShutdown(packet);
 		break;
-		case NetworkPacket::Type::PLAYER_NEW:
+		case SerialPacket::Type::PLAYER_NEW:
 			HandlePlayerNew(packet);
 		break;
-		case NetworkPacket::Type::PLAYER_DELETE:
+		case SerialPacket::Type::PLAYER_DELETE:
 			HandlePlayerDelete(packet);
 		break;
-		case NetworkPacket::Type::PLAYER_UPDATE:
+		case SerialPacket::Type::PLAYER_UPDATE:
 			HandlePlayerUpdate(packet);
 		break;
-		case NetworkPacket::Type::REGION_REQUEST:
+		case SerialPacket::Type::REGION_REQUEST:
 			HandleRegionRequest(packet);
 		break;
 		//handle errors
 		default:
-			throw(std::runtime_error("Unknown NetworkPacket::Type encountered"));
+			throw(std::runtime_error("Unknown SerialPacket::Type encountered"));
 		break;
 	}
 }
@@ -173,9 +173,9 @@ void ServerApplication::HandlePacket(NetworkPacket packet) {
 //Handle various network input
 //-------------------------
 
-void ServerApplication::HandleBroadcastRequest(NetworkPacket packet) {
+void ServerApplication::HandleBroadcastRequest(SerialPacket packet) {
 	//send back the server's metadata
-	packet.meta.type = NetworkPacket::Type::BROADCAST_RESPONSE;
+	packet.meta.type = SerialPacket::Type::BROADCAST_RESPONSE;
 	//TODO: version info
 	snprintf(packet.serverInfo.name, PACKET_STRING_SIZE, "%s", config["server.name"].c_str());
 	//TODO: player count
@@ -185,7 +185,7 @@ void ServerApplication::HandleBroadcastRequest(NetworkPacket packet) {
 	network.Send(&packet.meta.srcAddress, buffer, PACKET_BUFFER_SIZE);
 }
 
-void ServerApplication::HandleJoinRequest(NetworkPacket packet) {
+void ServerApplication::HandleJoinRequest(SerialPacket packet) {
 	//register the new client
 	ClientEntry newClient;
 	newClient.address = packet.meta.srcAddress;
@@ -193,7 +193,7 @@ void ServerApplication::HandleJoinRequest(NetworkPacket packet) {
 
 	//send the client their index
 	char buffer[PACKET_BUFFER_SIZE];
-	packet.meta.type = NetworkPacket::Type::JOIN_RESPONSE;
+	packet.meta.type = SerialPacket::Type::JOIN_RESPONSE;
 	packet.clientInfo.index = ClientEntry::uidCounter;
 	serialize(&packet, buffer);
 
@@ -205,7 +205,7 @@ void ServerApplication::HandleJoinRequest(NetworkPacket packet) {
 	std::cout << "Connect, total: " << clientMap.size() << std::endl;
 }
 
-void ServerApplication::HandleDisconnect(NetworkPacket packet) {
+void ServerApplication::HandleDisconnect(SerialPacket packet) {
 	//TODO: authenticate who is disconnecting/kicking
 
 	//disconnect the specified client
@@ -215,8 +215,8 @@ void ServerApplication::HandleDisconnect(NetworkPacket packet) {
 	clientMap.erase(packet.clientInfo.index);
 
 	//prep the delete packet
-	NetworkPacket delPacket;
-	delPacket.meta.type = NetworkPacket::Type::PLAYER_DELETE;
+	SerialPacket delPacket;
+	delPacket.meta.type = SerialPacket::Type::PLAYER_DELETE;
 
 	//TODO: can this use DeletePlayer() instead?
 	//delete server and client side players
@@ -239,17 +239,17 @@ void ServerApplication::HandleDisconnect(NetworkPacket packet) {
 	std::cout << "Disconnect, total: " << clientMap.size() << std::endl;
 }
 
-void ServerApplication::HandleSynchronize(NetworkPacket packet) {
+void ServerApplication::HandleSynchronize(SerialPacket packet) {
 	//TODO: compensate for large distances
 
 	//send all the server's data to this client
-	NetworkPacket newPacket;
+	SerialPacket newPacket;
 	char buffer[PACKET_BUFFER_SIZE];
 
 	//TODO: map?
 
 	//players
-	newPacket.meta.type = NetworkPacket::Type::PLAYER_UPDATE;
+	newPacket.meta.type = SerialPacket::Type::PLAYER_UPDATE;
 	for (auto& it : playerMap) {
 		//TODO: update this for the expanded PlayerEntry structure
 		newPacket.playerInfo.playerIndex = it.first;
@@ -262,19 +262,19 @@ void ServerApplication::HandleSynchronize(NetworkPacket packet) {
 	}
 }
 
-void ServerApplication::HandleShutdown(NetworkPacket packet) {
+void ServerApplication::HandleShutdown(SerialPacket packet) {
 	//end the server
 	running = false;
 
 	//disconnect all clients
-	packet.meta.type = NetworkPacket::Type::DISCONNECT;
+	packet.meta.type = SerialPacket::Type::DISCONNECT;
 	PumpPacket(packet);
 
 	//finished this routine
 	std::cout << "Shutdown signal accepted" << std::endl;
 }
 
-void ServerApplication::HandlePlayerNew(NetworkPacket packet) {
+void ServerApplication::HandlePlayerNew(SerialPacket packet) {
 	//register the new PlayerEntry
 	//NOTE: assigning each field one-by-one so adding or moving a field doesn't break this code
 	PlayerEntry newPlayer;
@@ -308,7 +308,7 @@ void ServerApplication::HandlePlayerNew(NetworkPacket packet) {
 	PlayerEntry::uidCounter++;
 }
 
-void ServerApplication::HandlePlayerDelete(NetworkPacket packet) {
+void ServerApplication::HandlePlayerDelete(SerialPacket packet) {
 	//TODO: remove this?
 	//TODO: authenticate who is deleting this player
 	if (playerMap.find(packet.playerInfo.playerIndex) == playerMap.end()) {
@@ -316,8 +316,8 @@ void ServerApplication::HandlePlayerDelete(NetworkPacket packet) {
 	}
 
 	//prep the delete packet
-	NetworkPacket delPacket;
-	delPacket.meta.type = NetworkPacket::Type::PLAYER_DELETE;
+	SerialPacket delPacket;
+	delPacket.meta.type = SerialPacket::Type::PLAYER_DELETE;
 
 	//delete the specified playerEntry
 	erase_if(playerMap, [&](std::pair<unsigned int, PlayerEntry> it) -> bool {
@@ -335,7 +335,7 @@ void ServerApplication::HandlePlayerDelete(NetworkPacket packet) {
 	});
 }
 
-void ServerApplication::HandlePlayerUpdate(NetworkPacket packet) {
+void ServerApplication::HandlePlayerUpdate(SerialPacket packet) {
 	if (playerMap.find(packet.playerInfo.playerIndex) == playerMap.end()) {
 		throw(std::runtime_error("Cannot update a non-existant player"));
 	}
@@ -347,15 +347,15 @@ void ServerApplication::HandlePlayerUpdate(NetworkPacket packet) {
 	PumpPacket(packet);
 }
 
-void ServerApplication::HandleRegionRequest(NetworkPacket packet) {
+void ServerApplication::HandleRegionRequest(SerialPacket packet) {
 	char buffer[PACKET_BUFFER_SIZE];
-	packet.meta.type = NetworkPacket::Type::REGION_CONTENT;
+	packet.meta.type = SerialPacket::Type::REGION_CONTENT;
 	packet.regionInfo.region = regionPager.GetRegion(packet.regionInfo.x, packet.regionInfo.y);
 	serialize(&packet, buffer);
 	network.Send(&packet.meta.srcAddress, buffer, PACKET_BUFFER_SIZE);
 }
 
-void ServerApplication::PumpPacket(NetworkPacket packet) {
+void ServerApplication::PumpPacket(SerialPacket packet) {
 	//I don't really like this, but it'll do for now
 	char buffer[PACKET_BUFFER_SIZE];
 	serialize(&packet, buffer);

server/server_application.hpp

@@ -33,7 +33,7 @@
 #include "region_pager.hpp"
 
 //networking
-#include "network_packet.hpp"
+#include "serial_packet.hpp"
 #include "udp_network_utility.hpp"
 #include "serial.hpp"
 
@@ -57,25 +57,25 @@ public:
 	~ServerApplication() = default;
 
 	void Init(int argc, char** argv);
-	void Loop();
+	void Proc();
 	void Quit();
 
 private:
-	void HandlePacket(NetworkPacket);
+	void HandlePacket(SerialPacket);
 
 	//high cohesion utility functions
-	void HandleBroadcastRequest(NetworkPacket);
-	void HandleJoinRequest(NetworkPacket);
-	void HandleDisconnect(NetworkPacket);
-	void HandleSynchronize(NetworkPacket);
-	void HandleShutdown(NetworkPacket);
-	void HandlePlayerNew(NetworkPacket);
-	void HandlePlayerDelete(NetworkPacket);
-	void HandlePlayerUpdate(NetworkPacket);
-	void HandleRegionRequest(NetworkPacket);
+	void HandleBroadcastRequest(SerialPacket);
+	void HandleJoinRequest(SerialPacket);
+	void HandleDisconnect(SerialPacket);
+	void HandleSynchronize(SerialPacket);
+	void HandleShutdown(SerialPacket);
+	void HandlePlayerNew(SerialPacket);
+	void HandlePlayerDelete(SerialPacket);
+	void HandlePlayerUpdate(SerialPacket);
+	void HandleRegionRequest(SerialPacket);
 
 	//TODO: a function that sends to players in a certain proximity
-	void PumpPacket(NetworkPacket);
+	void PumpPacket(SerialPacket);
 
 	//APIs
 	UDPNetworkUtility network;

server/server_utility.cpp

@@ -21,10 +21,14 @@
 */
 #include "server_utility.hpp"
 
+#include "utility.hpp"
+
+#include <stdexcept>
 #include <fstream>
+#include <cstdlib>
 
-
-int runSQLScript(sqlite3* db, std::string fname) {
+int runSQLScript(sqlite3* db, std::string fname, int (*callback)(void*,int,char**,char**), void* argPtr) {
+	//load the file into a string
 	std::ifstream is(fname);
 	if (!is.is_open()) {
 		return -1;
@@ -32,9 +36,15 @@ int runSQLScript(sqlite3* db, std::string fname) {
 	std::string script;
 	getline(is, script, '\0');
 	is.close();
-	//NOTE: flesh out this error if needed
-	if (sqlite3_exec(db, script.c_str(), nullptr, nullptr, nullptr) != SQLITE_OK) {
-		return -2;
+
+	//run the SQL loaded from the file
+	char* errmsg = nullptr;
+	int ret = sqlite3_exec(db, script.c_str(), callback, argPtr, &errmsg);
+	if (ret != SQLITE_OK) {
+		//handle any errors received from the SQL
+		std::runtime_error e(std::string() + "SQL Script Error " + to_string_custom(ret) + ": " + errmsg);
+		free(errmsg);
+		throw(e);
 	}
-	return 0;
+	return ret;
 }

server/server_utility.hpp

@@ -26,6 +26,6 @@
 
 #include <string>
 
-int runSQLScript(sqlite3* db, std::string fname);
+int runSQLScript(sqlite3* db, std::string fname, int (*callback)(void*,int,char**,char**) = nullptr, void* argPtr = nullptr);
 
 #endif