Ratstail91/Tortuga
Archived
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Renamed NetworkPacket to SerialPacket, updated build

Browse Source
This commit is contained in:
Kayne Ruse
2014-04-20 23:53:00 +10:00
parent f56cb58dfb
commit 4270765146
13 changed files with 166 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client/client_application.cpp
+2
View File
@@ -21,6 +21,8 @@
*/
#include "client_application.hpp"
#include "serial.hpp"
#include <stdexcept>
#include <chrono>
client/client_application.hpp
+1 -1
View File
@@ -26,11 +26,11 @@
#include "base_scene.hpp"
#include "config_utility.hpp"
#include "network_packet.hpp"
#include "udp_network_utility.hpp"
class ClientApplication {
private:
//TODO: I don't want singletons
ClientApplication();
~ClientApplication();
static ClientApplication instance;
client/scenes/in_world.cpp
+24 -24
View File
@@ -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
+7 -7
View File
@@ -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
+9 -9
View File
@@ -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
+2 -2
View File
@@ -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
+66 -66
View File
@@ -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
+4 -4
View File
@@ -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/network_packet.hpp → common/network/serial_packet.hpp
+4 -5
View File
@@ -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.hpp
+1
View File
@@ -28,6 +28,7 @@
class EditorApplication {
private:
//TODO: I don't want singletons
EditorApplication();
~EditorApplication();
static EditorApplication instance;
makefile
+1
View File
@@ -1,3 +1,4 @@
#TODO: The build process needs revising
#for use on Windows:
#MKDIR=mkdir
server/server_application.cpp
+33 -33
View File
@@ -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
@@ -98,7 +98,7 @@ void ServerApplication::Init(int argc, char** argv) {
}
void ServerApplication::Loop() {
NetworkPacket packet;
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
+12 -12
View File
@@ -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"
@@ -61,21 +61,21 @@ public:
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;