diff --git a/common/network/packet/serial_packet_base.hpp b/common/network/packet/serial_packet_base.hpp index 16279c8..760e54a 100644 --- a/common/network/packet/serial_packet_base.hpp +++ b/common/network/packet/serial_packet_base.hpp @@ -30,6 +30,7 @@ #include "SDL/SDL_net.h" +#define NETWORK_VERSION 20140607 #define PACKET_STRING_SIZE 100 struct SerialPacketBase { @@ -39,7 +40,7 @@ struct SerialPacketBase { typedef SerialPacketType Type; - virtual ~SerialPacketBase(); + virtual ~SerialPacketBase() {}; }; typedef SerialPacketBase SerialPacket; diff --git a/server/account_manager.cpp b/server/account_manager.cpp index 4a9bdc4..2a5a968 100644 --- a/server/account_manager.cpp +++ b/server/account_manager.cpp @@ -42,11 +42,11 @@ AccountManager::AccountManager() { AccountManager::~AccountManager() { for (auto& it : accountMap) { - SaveUserAccount(it.first); + SaveAccount(it.first); } } -int AccountManager::CreateUserAccount(std::string username, int clientIndex) { +int AccountManager::CreateAccount(std::string username, int clientIndex) { //create this user account, failing if it exists, leave this account in memory sqlite3_stmt* statement = nullptr; @@ -70,10 +70,10 @@ int AccountManager::CreateUserAccount(std::string username, int clientIndex) { sqlite3_finalize(statement); //load this account into memory - return LoadUserAccount(username, clientIndex); + return LoadAccount(username, clientIndex); } -int AccountManager::LoadUserAccount(std::string username, int clientIndex) { +int AccountManager::LoadAccount(std::string username, int clientIndex) { //load this user account, failing if it is in memory, creating it if it doesn't exist sqlite3_stmt* statement = nullptr; @@ -119,13 +119,13 @@ int AccountManager::LoadUserAccount(std::string username, int clientIndex) { if (ret == SQLITE_DONE) { //create the non-existant account instead - return CreateUserAccount(username, clientIndex); + return CreateAccount(username, clientIndex); } - throw(std::runtime_error(std::string() + "Unknown SQL error in LoadUserAccount: " + sqlite3_errmsg(database) )); + throw(std::runtime_error(std::string() + "Unknown SQL error in LoadAccount: " + sqlite3_errmsg(database) )); } -int AccountManager::SaveUserAccount(int uid) { +int AccountManager::SaveAccount(int uid) { //save this user account from memory, replacing it if it exists in the database //DOCS: To use this method, change the in-memory copy, and then call this function using that object's UID. @@ -168,14 +168,14 @@ int AccountManager::SaveUserAccount(int uid) { return 0; } -void AccountManager::UnloadUserAccount(int uid) { +void AccountManager::UnloadAccount(int uid) { //save this user account, and then unload it //NOTE: the associated characters are unloaded externally - SaveUserAccount(uid); + SaveAccount(uid); accountMap.erase(uid); } -void AccountManager::DeleteUserAccount(int uid) { +void AccountManager::DeleteAccount(int uid) { //delete a user account from the database, and remove it from memory //NOTE: the associated characters should be deleted externally sqlite3_stmt* statement = nullptr; diff --git a/server/account_manager.hpp b/server/account_manager.hpp index 10ba8a3..5bf3841 100644 --- a/server/account_manager.hpp +++ b/server/account_manager.hpp @@ -34,11 +34,11 @@ public: ~AccountManager(); //public access methods - int CreateUserAccount(std::string username, int clientIndex); - int LoadUserAccount(std::string username, int clientIndex); - int SaveUserAccount(int uid); - void UnloadUserAccount(int uid); - void DeleteUserAccount(int uid); + int CreateAccount(std::string username, int clientIndex); + int LoadAccount(std::string username, int clientIndex); + int SaveAccount(int uid); + void UnloadAccount(int uid); + void DeleteAccount(int uid); //accessors and mutators AccountData* GetAccount(int uid); diff --git a/server/character_manager.cpp b/server/character_manager.cpp index 1192788..34310c9 100644 --- a/server/character_manager.cpp +++ b/server/character_manager.cpp @@ -283,6 +283,18 @@ void CharacterManager::DeleteCharacter(int uid) { characterMap.erase(uid); } +void CharacterManager::UnloadCharacterIf(std::function::iterator)> f) { + //save this character, then unload it if the parameter returns true + for (std::map::iterator it = characterMap.begin(); it != characterMap.end(); /* EMPTY */ ) { + if (f(it)) { + SaveCharacter(it->first); + it = characterMap.erase(it); + continue; + } + it++; + } +} + //------------------------- //Define the accessors and mutators //------------------------- diff --git a/server/character_manager.hpp b/server/character_manager.hpp index 97b3a18..812d337 100644 --- a/server/character_manager.hpp +++ b/server/character_manager.hpp @@ -27,6 +27,7 @@ #include "sqlite3/sqlite3.h" #include +#include class CharacterManager { public: @@ -40,6 +41,8 @@ public: void UnloadCharacter(int uid); void DeleteCharacter(int uid); + void UnloadCharacterIf(std::function::iterator)> f); + //accessors and mutators CharacterData* GetCharacter(int uid); std::map* GetContainer(); diff --git a/server/server_application.cpp b/server/server_application.cpp index 24c71cc..7ef5f45 100644 --- a/server/server_application.cpp +++ b/server/server_application.cpp @@ -106,7 +106,7 @@ void ServerApplication::Init(int argc, char** argv) { std::cout << "Internal sizes:" << std::endl; std::cout << "\tTile Size: " << sizeof(Region::type_t) << std::endl; - std::cout << "\tRegion Format: " << REGION_WIDTH << ", " << REGION_HEIGHT << ", " << REGION_DEPTH << << std::endl; + std::cout << "\tRegion Format: " << REGION_WIDTH << ", " << REGION_HEIGHT << ", " << REGION_DEPTH << std::endl; std::cout << "\tRegion Content Footprint: " << REGION_WIDTH * REGION_HEIGHT * REGION_DEPTH * sizeof(Region::type_t) << std::endl; std::cout << "\tPACKET_BUFFER_SIZE (max size): " << PACKET_BUFFER_SIZE << std::endl; @@ -122,7 +122,7 @@ void ServerApplication::Proc() { while(running) { //suck in the waiting packets & process them while(network.Receive(&packet)) { - HandlePacket(packet); + HandlePacket(&packet); } //update the internals //TODO: update the internals i.e. player positions @@ -148,25 +148,25 @@ void ServerApplication::Quit() { //handle incoming traffic //------------------------- -void ServerApplication::HandlePacket(SerialPacket packet) { - switch(packet.meta.type) { +void ServerApplication::HandlePacket(SerialPacket* const argPacket) { + switch(argPacket->type) { //basic connections case SerialPacketType::BROADCAST_REQUEST: - HandleBroadcastRequest(packet); + HandleBroadcastRequest(dynamic_cast(argPacket)); break; case SerialPacketType::JOIN_REQUEST: - HandleJoinRequest(packet); + HandleJoinRequest(dynamic_cast(argPacket)); break; case SerialPacketType::DISCONNECT: - HandleDisconnect(packet); + HandleDisconnect(dynamic_cast(argPacket)); break; case SerialPacketType::SHUTDOWN: - HandleShutdown(packet); + HandleShutdown(dynamic_cast(argPacket)); break; //map management case SerialPacketType::REGION_REQUEST: - HandleRegionRequest(packet); + HandleRegionRequest(dynamic_cast(argPacket)); break; //combat management @@ -174,14 +174,14 @@ void ServerApplication::HandlePacket(SerialPacket packet) { //character management case SerialPacketType::CHARACTER_NEW: - HandleCharacterNew(packet); + HandleCharacterNew(dynamic_cast(argPacket)); break; case SerialPacketType::CHARACTER_DELETE: - HandleCharacterDelete(packet); + HandleCharacterDelete(dynamic_cast(argPacket)); break; case SerialPacketType::CHARACTER_UPDATE: case SerialPacketType::CHARACTER_STATS_REQUEST: //TODO: ? - HandleCharacterUpdate(packet); + HandleCharacterUpdate(dynamic_cast(argPacket)); break; //enemy management @@ -189,12 +189,12 @@ void ServerApplication::HandlePacket(SerialPacket packet) { //mismanagement case SerialPacketType::SYNCHRONIZE: - HandleSynchronize(packet); + HandleSynchronize(dynamic_cast(argPacket)); break; //handle errors default: - throw(std::runtime_error(std::string() + "Unknown SerialPacketType encountered in the server: " + to_string_custom(int(packet.type)))); + throw(std::runtime_error(std::string() + "Unknown SerialPacketType encountered in the server: " + to_string_custom(int(argPacket->type)))); break; } } @@ -203,129 +203,82 @@ void ServerApplication::HandlePacket(SerialPacket packet) { //basic connections //------------------------- -void ServerApplication::HandleBroadcastRequest(SerialPacket packet) { - //pack the server's data - packet.meta.type = SerialPacket::Type::BROADCAST_RESPONSE; - packet.serverInfo.networkVersion = NETWORK_VERSION; - snprintf(packet.serverInfo.name, PACKET_STRING_SIZE, "%s", config["server.name"].c_str()); - packet.serverInfo.playerCount = characterMap.size(); +void ServerApplication::HandleBroadcastRequest(SerialPacket* const argPacket) { + //send the server's data + ServerPacket newPacket; - //bounce this packet - network.SendTo(&packet.meta.srcAddress, &packet); + newPacket.type = SerialPacketType::BROADCAST_RESPONSE; + snprintf(newPacket.name, PACKET_STRING_SIZE, "%s", config["server.name"].c_str()); + newPacket.playerCount = characterMgr.GetContainer()->size(); + newPacket.version = NETWORK_VERSION; + + network.SendTo(&argPacket->srcAddress, dynamic_cast(&newPacket)); } -void ServerApplication::HandleJoinRequest(SerialPacket packet) { +void ServerApplication::HandleJoinRequest(ClientPacket* const argPacket) { //create the new client ClientData newClient; - newClient.address = packet.meta.srcAddress; + newClient.address = argPacket->srcAddress; //load the user account - int accountIndex = LoadUserAccount(packet.clientInfo.username, clientUID); + //TODO: handle passwords + int accountIndex = accountMgr.LoadAccount(argPacket->username, clientUID); if (accountIndex < 0) { //TODO: send rejection packet std::cerr << "Error: Account already loaded: " << accountIndex << std::endl; return; } - //load the new character - int characterIndex = LoadCharacter(accountIndex, packet.clientInfo.handle, packet.clientInfo.avatar); - if (characterIndex < 0) { - //TODO: send rejection packet - std::cerr << "Error: Character already loaded: " << characterIndex << std::endl; - UnloadUserAccount(accountIndex); - return; - } - //send the client their info - packet.meta.type = SerialPacket::Type::JOIN_RESPONSE; - packet.clientInfo.clientIndex = clientUID; - packet.clientInfo.accountIndex = accountIndex; - packet.clientInfo.characterIndex = characterIndex; + ClientPacket newPacket; + newPacket.type = SerialPacketType::JOIN_RESPONSE; + newPacket.clientIndex = clientUID; + newPacket.accountIndex = accountIndex; - //bounce this packet - network.SendTo(&newClient.address, &packet); + network.SendTo(&newClient.address, dynamic_cast(&newPacket)); - //reference to prevent multiple lookups - //TODO: I need a way to pack structures unto packets more easily - //NOTE: this chunk of code is similar to HandleSynchronize - CharacterData& character = characterMap[characterIndex]; - - //send the new character to all clients - packet.meta.type = SerialPacket::Type::CHARACTER_NEW; - packet.characterInfo.characterIndex = characterIndex; - strncpy(packet.characterInfo.handle, character.handle.c_str(), PACKET_STRING_SIZE); - strncpy(packet.characterInfo.avatar, character.avatar.c_str(), PACKET_STRING_SIZE); - packet.characterInfo.mapIndex = character.mapIndex; - packet.characterInfo.origin = character.origin; - packet.characterInfo.motion = character.motion; - packet.characterInfo.stats = character.stats; - - PumpPacket(packet); - - //TODO: don't send anything to a certain client until they send the OK (the sync packet? or ignore client side?) //finished this routine clientMap[clientUID++] = newClient; - std::cout << "Connect, total: " << clientMap.size() << std::endl; + std::cout << "New connection, " << clientMap.size() << " clients and " << accountMgr.GetContainer()->size() << " accounts total" << std::endl; } -void ServerApplication::HandleSynchronize(SerialPacket packet) { - //TODO: compensate for large distances - - //send all the server's data to this client - SerialPacket newPacket; - - //characters - newPacket.meta.type = SerialPacket::Type::CHARACTER_UPDATE; - for (auto& it : characterMap) { - //TODO: update this for the expanded CharacterData structure - newPacket.characterInfo.characterIndex = it.first; - snprintf(newPacket.characterInfo.handle, PACKET_STRING_SIZE, "%s", it.second.handle.c_str()); - snprintf(newPacket.characterInfo.avatar, PACKET_STRING_SIZE, "%s", it.second.avatar.c_str()); - newPacket.characterInfo.mapIndex = it.second.mapIndex; - newPacket.characterInfo.origin = it.second.origin; - newPacket.characterInfo.motion = it.second.motion; - newPacket.characterInfo.stats = it.second.stats; - - network.SendTo(&clientMap[packet.clientInfo.clientIndex].address, &newPacket); - } -} - -void ServerApplication::HandleDisconnect(SerialPacket packet) { +void ServerApplication::HandleDisconnect(ClientPacket* const argPacket) { //TODO: authenticate who is disconnecting/kicking //forward to the specified client - network.SendTo(&clientMap[accountMap[packet.clientInfo.accountIndex].clientIndex].address, &packet); + network.SendTo( + &clientMap[ accountMgr.GetAccount(argPacket->accountIndex)->clientIndex ].address, + dynamic_cast(argPacket) + ); - //unload client and server-side characters - for (std::map::iterator it = characterMap.begin(); it != characterMap.end(); /* EMPTY */ ) { - if (it->second.owner == packet.clientInfo.accountIndex) { + //save and unload this account's characters + //pump the unload message to all remaining clients + characterMgr.UnloadCharacterIf([&](std::map::iterator it) -> bool { + if (argPacket->accountIndex == it->second.owner) { PumpCharacterUnload(it->first); - SaveCharacter(it->first); - it = characterMap.erase(it); //efficient - continue; + return true; } - else { - ++it; - } - } + return false; + }); //erase the in-memory stuff - clientMap.erase(accountMap[packet.clientInfo.accountIndex].clientIndex); - UnloadUserAccount(packet.clientInfo.accountIndex); + clientMap.erase(accountMgr.GetAccount(argPacket->accountIndex)->clientIndex); + accountMgr.UnloadAccount(argPacket->accountIndex); //finished this routine - std::cout << "Disconnect, total: " << clientMap.size() << std::endl; + std::cout << "Disconnection, " << clientMap.size() << " clients and " << accountMgr.GetContainer()->size() << " accounts total" << std::endl; } -void ServerApplication::HandleShutdown(SerialPacket packet) { +void ServerApplication::HandleShutdown(SerialPacket* const argPacket) { //TODO: authenticate who is shutting the server down //end the server running = false; //disconnect all clients - packet.meta.type = SerialPacket::Type::DISCONNECT; - PumpPacket(packet); + SerialPacket newPacket; + newPacket.type = SerialPacketType::DISCONNECT; + PumpPacket(&newPacket); //finished this routine std::cout << "Shutdown signal accepted" << std::endl; @@ -335,13 +288,18 @@ void ServerApplication::HandleShutdown(SerialPacket packet) { //map management //------------------------- -void ServerApplication::HandleRegionRequest(SerialPacket packet) { - //TODO: this should be moved elsewhere - packet.meta.type = SerialPacket::Type::REGION_CONTENT; - packet.regionInfo.region = regionPager.GetRegion(packet.regionInfo.x, packet.regionInfo.y); +void ServerApplication::HandleRegionRequest(RegionPacket* const argPacket) { + RegionPacket newPacket; + + newPacket.type = SerialPacketType::REGION_CONTENT; + newPacket.roomIndex = argPacket->roomIndex; + newPacket.x = argPacket->x; + newPacket.y = argPacket->y; + + newPacket.region = roomMgr.GetRoom(argPacket->roomIndex)->GetPager()->GetRegion(argPacket->x, argPacket->y); //send the content - network.SendTo(&packet.meta.srcAddress, &packet); + network.SendTo(&argPacket->srcAddress, dynamic_cast(argPacket)); } //------------------------- @@ -381,6 +339,32 @@ void ServerApplication::HandleCharacterUpdate(SerialPacket packet) { //TODO: enemy management +//------------------------- +//mismanagement +//------------------------- + +void ServerApplication::HandleSynchronize(SerialPacket packet) { + //TODO: compensate for large distances + + //send all the server's data to this client + SerialPacket newPacket; + + //characters + newPacket.meta.type = SerialPacket::Type::CHARACTER_UPDATE; + for (auto& it : characterMap) { + //TODO: update this for the expanded CharacterData structure + newPacket.characterInfo.characterIndex = it.first; + snprintf(newPacket.characterInfo.handle, PACKET_STRING_SIZE, "%s", it.second.handle.c_str()); + snprintf(newPacket.characterInfo.avatar, PACKET_STRING_SIZE, "%s", it.second.avatar.c_str()); + newPacket.characterInfo.mapIndex = it.second.mapIndex; + newPacket.characterInfo.origin = it.second.origin; + newPacket.characterInfo.motion = it.second.motion; + newPacket.characterInfo.stats = it.second.stats; + + network.SendTo(&clientMap[packet.clientInfo.clientIndex].address, &newPacket); + } +} + //------------------------- //utility methods //------------------------- diff --git a/server/server_application.hpp b/server/server_application.hpp index cab0e1f..a0cb9b3 100644 --- a/server/server_application.hpp +++ b/server/server_application.hpp @@ -61,34 +61,34 @@ public: private: //handle incoming traffic - void HandlePacket(SerialPacket); + void HandlePacket(SerialPacket* const); //basic connections - void HandleBroadcastRequest(SerialPacket); - void HandleJoinRequest(SerialPacket); - void HandleDisconnect(SerialPacket); - void HandleShutdown(SerialPacket); + void HandleBroadcastRequest(SerialPacket* const); + void HandleJoinRequest(ClientPacket* const); + void HandleDisconnect(ClientPacket* const); + void HandleShutdown(SerialPacket* const); //map management - void HandleRegionRequest(SerialPacket); + void HandleRegionRequest(RegionPacket* const); //combat management //TODO: combat management //character management - void HandleCharacterNew(SerialPacket); - void HandleCharacterDelete(SerialPacket); - void HandleCharacterUpdate(SerialPacket); + void HandleCharacterNew(SerialPacket* const); + void HandleCharacterDelete(SerialPacket* const); + void HandleCharacterUpdate(SerialPacket* const); //enemy management //TODO: enemy management //mismanagement - void HandleSynchronize(SerialPacket); + void HandleSynchronize(SerialPacket* const); //utility methods //TODO: a function that only sends to characters in a certain proximity - void PumpPacket(SerialPacket); + void PumpPacket(SerialPacket* const); void PumpCharacterUnload(int uid); //APIs and utilities