From d1e9ad92c1a9d100d7f9ba50efec64a290cf7384 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sat, 22 Aug 2020 15:52:02 +0200 Subject: [PATCH 01/22] Update NanoManager.hpp --- src/NanoManager.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/NanoManager.hpp b/src/NanoManager.hpp index 748851f..942f63a 100644 --- a/src/NanoManager.hpp +++ b/src/NanoManager.hpp @@ -12,6 +12,7 @@ namespace NanoManager { void nanoSkillUseHandler(CNSocket* sock, CNPacketData* data); void nanoSkillSetHandler(CNSocket* sock, CNPacketData* data); + // Helper methods void addNano(CNSocket* sock, int16_t nanoId, int16_t slot); void setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId); void resetNanoSkill(CNSocket* sock, int16_t nanoId); From a985da49432996e601aaeecdc11f336ed2ba1819 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sat, 22 Aug 2020 15:57:57 +0200 Subject: [PATCH 02/22] Update PlayerManager.hpp --- src/PlayerManager.hpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/PlayerManager.hpp b/src/PlayerManager.hpp index 34ca836..3105f51 100644 --- a/src/PlayerManager.hpp +++ b/src/PlayerManager.hpp @@ -42,7 +42,6 @@ namespace PlayerManager { void setSpecialPlayer(CNSocket* sock, CNPacketData* data); void heartbeatPlayer(CNSocket* sock, CNPacketData* data); void exitGame(CNSocket* sock, CNPacketData* data); - void onPlayerSpawn(CNSocket* sock, CNPacketData* data); } #endif From 70816e3e64976dc7b48d00b9b5fafcee06cb3566 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sat, 22 Aug 2020 16:39:49 +0200 Subject: [PATCH 03/22] Update PlayerManager.cpp --- src/PlayerManager.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index 8a5f2a2..3018187 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -566,7 +566,4 @@ void PlayerManager::updatePlayer(CNSocket* key, Player plr) { plrv.plr = plr; players[key] = plrv; -} - -void PlayerManager::onPlayerSpawn(CNSocket* sock, CNPacketData* data) { } \ No newline at end of file From d618d1b35362c7f3dfdea43a3952a78e908a6f34 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sat, 22 Aug 2020 17:11:41 +0200 Subject: [PATCH 04/22] Updated indentations --- src/CNShardServer.hpp | 134 ++++---- src/NanoManager.cpp | 166 ++++----- src/NanoManager.hpp | 22 +- src/PlayerManager.cpp | 778 +++++++++++++++++++++--------------------- 4 files changed, 550 insertions(+), 550 deletions(-) diff --git a/src/CNShardServer.hpp b/src/CNShardServer.hpp index 608fa7e..7a85b83 100644 --- a/src/CNShardServer.hpp +++ b/src/CNShardServer.hpp @@ -6,84 +6,84 @@ #include enum SHARDPACKETID { - // client 2 shard - P_CL2FE_REQ_PC_ENTER = 318767105, - P_CL2FE_REQ_PC_LOADING_COMPLETE = 318767245, - P_CL2FE_REP_LIVE_CHECK = 318767221, - P_CL2FE_REQ_NANO_ACTIVE = 318767119, - P_CL2FE_REQ_NANO_EQUIP = 318767117, - P_CL2FE_REQ_NANO_UNEQUIP = 318767118, - P_CL2FE_REQ_NANO_SKILL_USE = 318767121, - P_CL2FE_REQ_NANO_TUNE = 318767120, - P_CL2FE_REQ_PC_FIRST_USE_FLAG_SET = 318767238, - P_CL2FE_REQ_PC_GIVE_NANO = 318767172, - P_CL2FE_REQ_PC_MOVE = 318767107, - P_CL2FE_REQ_PC_STOP = 318767108, - P_CL2FE_REQ_PC_JUMP = 318767109, - P_CL2FE_REQ_PC_JUMPPAD = 318767165, - P_CL2FE_REQ_PC_LAUNCHER = 318767166, - P_CL2FE_REQ_PC_ZIPLINE = 318767167, - P_CL2FE_REQ_PC_MOVEPLATFORM = 318767168, - P_CL2FE_REQ_PC_SLOPE = 318767169, - P_CL2FE_REQ_PC_GOTO = 318767124, - P_CL2FE_GM_REQ_PC_SET_VALUE = 318767211, - P_CL2FE_REQ_SEND_FREECHAT_MESSAGE = 318767111, - P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT = 318767184, - P_CL2FE_REQ_ITEM_MOVE = 318767114, - P_CL2FE_REQ_PC_ITEM_DELETE = 318767129, - P_CL2FE_REQ_PC_GIVE_ITEM = 318767130, - P_CL2FE_REQ_PC_EXIT = 318767106, + // client 2 shard + P_CL2FE_REQ_PC_ENTER = 318767105, + P_CL2FE_REQ_PC_LOADING_COMPLETE = 318767245, + P_CL2FE_REP_LIVE_CHECK = 318767221, + P_CL2FE_REQ_NANO_ACTIVE = 318767119, + P_CL2FE_REQ_NANO_EQUIP = 318767117, + P_CL2FE_REQ_NANO_UNEQUIP = 318767118, + P_CL2FE_REQ_NANO_SKILL_USE = 318767121, + P_CL2FE_REQ_NANO_TUNE = 318767120, + P_CL2FE_REQ_PC_FIRST_USE_FLAG_SET = 318767238, + P_CL2FE_REQ_PC_GIVE_NANO = 318767172, + P_CL2FE_REQ_PC_MOVE = 318767107, + P_CL2FE_REQ_PC_STOP = 318767108, + P_CL2FE_REQ_PC_JUMP = 318767109, + P_CL2FE_REQ_PC_JUMPPAD = 318767165, + P_CL2FE_REQ_PC_LAUNCHER = 318767166, + P_CL2FE_REQ_PC_ZIPLINE = 318767167, + P_CL2FE_REQ_PC_MOVEPLATFORM = 318767168, + P_CL2FE_REQ_PC_SLOPE = 318767169, + P_CL2FE_REQ_PC_GOTO = 318767124, + P_CL2FE_GM_REQ_PC_SET_VALUE = 318767211, + P_CL2FE_REQ_SEND_FREECHAT_MESSAGE = 318767111, + P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT = 318767184, + P_CL2FE_REQ_ITEM_MOVE = 318767114, + P_CL2FE_REQ_PC_ITEM_DELETE = 318767129, + P_CL2FE_REQ_PC_GIVE_ITEM = 318767130, + P_CL2FE_REQ_PC_EXIT = 318767106, - // shard 2 client - P_FE2CL_REP_NANO_ACTIVE_SUCC = 822083624, - P_FE2CL_REP_PC_NANO_CREATE_SUCC = 822083667, - P_FE2CL_REP_NANO_EQUIP_SUCC = 822083622, - P_FE2CL_REP_NANO_UNEQUIP_SUCC = 822083623, - P_FE2CL_NANO_SKILL_USE_SUCC = 822083627, - P_FE2CL_NANO_SKILL_USE = 822083628, - P_FE2CL_REP_NANO_TUNE_SUCC = 822083625, - P_FE2CL_REP_PC_ENTER_SUCC = 822083586, - P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC = 822083833, - P_FE2CL_REP_PC_GOTO_SUCC = 822083633, - P_FE2CL_REQ_LIVE_CHECK = 822083792, - P_FE2CL_PC_NEW = 822083587, - P_FE2CL_PC_MOVE = 822083592, - P_FE2CL_PC_STOP = 822083593, - P_FE2CL_PC_JUMP = 822083594, - P_FE2CL_PC_EXIT = 822083590, - P_FE2CL_PC_JUMPPAD = 822083701, - P_FE2CL_PC_LAUNCHER = 822083702, - P_FE2CL_PC_ZIPLINE = 822083703, - P_FE2CL_PC_MOVEPLATFORM = 822083704, - P_FE2CL_PC_SLOPE = 822083705, - P_FE2CL_NPC_ENTER = 822083595, - P_FE2CL_NPC_EXIT = 822083596, - P_FE2CL_ANNOUNCE_MSG = 822083778, - P_FE2CL_GM_REP_PC_SET_VALUE = 822083781, - P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC = 822083602, - P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT = 822083730, - P_FE2CL_PC_ITEM_MOVE_SUCC = 822083610, - P_FE2CL_PC_EQUIP_CHANGE = 822083611, - P_FE2CL_REP_PC_ITEM_DELETE_SUCC = 822083641, - P_FE2CL_REP_PC_GIVE_ITEM_SUCC = 822083681, - P_FE2CL_REP_PC_EXIT_SUCC = 822083589, - P_FE2CL_REP_PC_CHANGE_LEVEL = 822083786, - P_FE2CL_PC_MOTD_LOGIN = 822083793 + // shard 2 client + P_FE2CL_REP_NANO_ACTIVE_SUCC = 822083624, + P_FE2CL_REP_PC_NANO_CREATE_SUCC = 822083667, + P_FE2CL_REP_NANO_EQUIP_SUCC = 822083622, + P_FE2CL_REP_NANO_UNEQUIP_SUCC = 822083623, + P_FE2CL_NANO_SKILL_USE_SUCC = 822083627, + P_FE2CL_NANO_SKILL_USE = 822083628, + P_FE2CL_REP_NANO_TUNE_SUCC = 822083625, + P_FE2CL_REP_PC_ENTER_SUCC = 822083586, + P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC = 822083833, + P_FE2CL_REP_PC_GOTO_SUCC = 822083633, + P_FE2CL_REQ_LIVE_CHECK = 822083792, + P_FE2CL_PC_NEW = 822083587, + P_FE2CL_PC_MOVE = 822083592, + P_FE2CL_PC_STOP = 822083593, + P_FE2CL_PC_JUMP = 822083594, + P_FE2CL_PC_EXIT = 822083590, + P_FE2CL_PC_JUMPPAD = 822083701, + P_FE2CL_PC_LAUNCHER = 822083702, + P_FE2CL_PC_ZIPLINE = 822083703, + P_FE2CL_PC_MOVEPLATFORM = 822083704, + P_FE2CL_PC_SLOPE = 822083705, + P_FE2CL_NPC_ENTER = 822083595, + P_FE2CL_NPC_EXIT = 822083596, + P_FE2CL_ANNOUNCE_MSG = 822083778, + P_FE2CL_GM_REP_PC_SET_VALUE = 822083781, + P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC = 822083602, + P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT = 822083730, + P_FE2CL_PC_ITEM_MOVE_SUCC = 822083610, + P_FE2CL_PC_EQUIP_CHANGE = 822083611, + P_FE2CL_REP_PC_ITEM_DELETE_SUCC = 822083641, + P_FE2CL_REP_PC_GIVE_ITEM_SUCC = 822083681, + P_FE2CL_REP_PC_EXIT_SUCC = 822083589, + P_FE2CL_REP_PC_CHANGE_LEVEL = 822083786, + P_FE2CL_PC_MOTD_LOGIN = 822083793 }; #define REGISTER_SHARD_PACKET(pactype, handlr) CNShardServer::ShardPackets[pactype] = handlr; class CNShardServer : public CNServer { private: - static void handlePacket(CNSocket* sock, CNPacketData* data); + static void handlePacket(CNSocket* sock, CNPacketData* data); public: - static std::map ShardPackets; + static std::map ShardPackets; - CNShardServer(uint16_t p); + CNShardServer(uint16_t p); - void killConnection(CNSocket* cns); - void onTimer(); + void killConnection(CNSocket* cns); + void onTimer(); }; #endif diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index 70cf4c5..d0028c2 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -4,140 +4,140 @@ #include "PlayerManager.hpp" void NanoManager::init() { - REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_ACTIVE, nanoSummonHandler); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_EQUIP, nanoEquipHandler); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_UNEQUIP, nanoUnEquipHandler); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GIVE_NANO, nanoGMGiveHandler); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_TUNE, nanoSkillSetHandler); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_SKILL_USE, nanoSkillUseHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_ACTIVE, nanoSummonHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_EQUIP, nanoEquipHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_UNEQUIP, nanoUnEquipHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GIVE_NANO, nanoGMGiveHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_TUNE, nanoSkillSetHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_SKILL_USE, nanoSkillUseHandler); } void NanoManager::nanoEquipHandler(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_NANO_EQUIP)) - return; // malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_NANO_EQUIP)) + return; // malformed packet - sP_CL2FE_REQ_NANO_EQUIP* nano = (sP_CL2FE_REQ_NANO_EQUIP*)data->buf; - sP_FE2CL_REP_NANO_EQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_EQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC)); - resp->iNanoID = nano->iNanoID; - resp->iNanoSlotNum = nano->iNanoSlotNum; + sP_CL2FE_REQ_NANO_EQUIP* nano = (sP_CL2FE_REQ_NANO_EQUIP*)data->buf; + sP_FE2CL_REP_NANO_EQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_EQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC)); + resp->iNanoID = nano->iNanoID; + resp->iNanoSlotNum = nano->iNanoSlotNum; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_EQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_EQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC), sock->getFEKey())); } void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_NANO_UNEQUIP)) - return; // malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_NANO_UNEQUIP)) + return; // malformed packet - sP_CL2FE_REQ_NANO_UNEQUIP* nano = (sP_CL2FE_REQ_NANO_UNEQUIP*)data->buf; - sP_FE2CL_REP_NANO_UNEQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_UNEQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC)); - resp->iNanoSlotNum = nano->iNanoSlotNum; + sP_CL2FE_REQ_NANO_UNEQUIP* nano = (sP_CL2FE_REQ_NANO_UNEQUIP*)data->buf; + sP_FE2CL_REP_NANO_UNEQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_UNEQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC)); + resp->iNanoSlotNum = nano->iNanoSlotNum; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_UNEQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_UNEQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC), sock->getFEKey())); } void NanoManager::nanoGMGiveHandler(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_GIVE_NANO)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_GIVE_NANO)) + return; // ignore the malformed packet - // Cmd: /nano - sP_CL2FE_REQ_PC_GIVE_NANO* nano = (sP_CL2FE_REQ_PC_GIVE_NANO*)data->buf; - Player plr = PlayerManager::getPlayer(sock); + // Cmd: /nano + sP_CL2FE_REQ_PC_GIVE_NANO* nano = (sP_CL2FE_REQ_PC_GIVE_NANO*)data->buf; + Player plr = PlayerManager::getPlayer(sock); - // Add nano to player - addNano(sock, nano->iNanoID, 0); - std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " requested to add nano id: " << nano->iNanoID << std::endl; + // Add nano to player + addNano(sock, nano->iNanoID, 0); + std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " requested to add nano id: " << nano->iNanoID << std::endl; } void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_NANO_ACTIVE)) - return; // malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_NANO_ACTIVE)) + return; // malformed packet - sP_CL2FE_REQ_NANO_ACTIVE* nano = (sP_CL2FE_REQ_NANO_ACTIVE*)data->buf; - PlayerView plr = PlayerManager::players[sock]; + sP_CL2FE_REQ_NANO_ACTIVE* nano = (sP_CL2FE_REQ_NANO_ACTIVE*)data->buf; + PlayerView plr = PlayerManager::players[sock]; - // Send to client - sP_FE2CL_REP_NANO_ACTIVE_SUCC* resp = (sP_FE2CL_REP_NANO_ACTIVE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC)); - resp->iActiveNanoSlotNum = nano->iNanoSlotNum; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC), sock->getFEKey())); + // Send to client + sP_FE2CL_REP_NANO_ACTIVE_SUCC* resp = (sP_FE2CL_REP_NANO_ACTIVE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC)); + resp->iActiveNanoSlotNum = nano->iNanoSlotNum; + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC), sock->getFEKey())); - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; + std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; } void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_NANO_SKILL_USE)) - return; // malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_NANO_SKILL_USE)) + return; // malformed packet - sP_CL2FE_REQ_NANO_SKILL_USE* skill = (sP_CL2FE_REQ_NANO_SKILL_USE*)data->buf; - PlayerView plr = PlayerManager::players[sock]; + sP_CL2FE_REQ_NANO_SKILL_USE* skill = (sP_CL2FE_REQ_NANO_SKILL_USE*)data->buf; + PlayerView plr = PlayerManager::players[sock]; - // Send to client - sP_FE2CL_NANO_SKILL_USE_SUCC* resp = (sP_FE2CL_NANO_SKILL_USE_SUCC*)xmalloc(sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC)); - resp->iArg1 = skill->iArg1; - resp->iArg2 = skill->iArg2; - resp->iArg3 = skill->iArg3; - resp->iBulletID = skill->iBulletID; - resp->iTargetCnt = skill->iTargetCnt; - resp->iPC_ID = plr.plr.iID; - resp->iNanoStamina = 150; // Hardcoded for now + // Send to client + sP_FE2CL_NANO_SKILL_USE_SUCC* resp = (sP_FE2CL_NANO_SKILL_USE_SUCC*)xmalloc(sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC)); + resp->iArg1 = skill->iArg1; + resp->iArg2 = skill->iArg2; + resp->iArg3 = skill->iArg3; + resp->iBulletID = skill->iBulletID; + resp->iTargetCnt = skill->iTargetCnt; + resp->iPC_ID = plr.plr.iID; + resp->iNanoStamina = 150; // Hardcoded for now - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), sock->getFEKey())); - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; + std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; } void NanoManager::nanoSkillSetHandler(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_NANO_TUNE)) - return; // malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_NANO_TUNE)) + return; // malformed packet - sP_CL2FE_REQ_NANO_TUNE* skill = (sP_CL2FE_REQ_NANO_TUNE*)data->buf; - setNanoSkill(sock, skill->iNanoID, skill->iTuneID); + sP_CL2FE_REQ_NANO_TUNE* skill = (sP_CL2FE_REQ_NANO_TUNE*)data->buf; + setNanoSkill(sock, skill->iNanoID, skill->iTuneID); } #pragma region Helper methods void NanoManager::addNano(CNSocket* sock, int16_t nanoId, int16_t slot) { - Player plr = PlayerManager::getPlayer(sock); + Player plr = PlayerManager::getPlayer(sock); - // Send to client - sP_FE2CL_REP_PC_NANO_CREATE_SUCC* resp = new sP_FE2CL_REP_PC_NANO_CREATE_SUCC(); - resp->Nano.iID = nanoId; - resp->Nano.iStamina = 150; - resp->iQuestItemSlotNum = slot; + // Send to client + sP_FE2CL_REP_PC_NANO_CREATE_SUCC* resp = new sP_FE2CL_REP_PC_NANO_CREATE_SUCC(); + resp->Nano.iID = nanoId; + resp->Nano.iStamina = 150; + resp->iQuestItemSlotNum = slot; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_NANO_CREATE_SUCC, sizeof(sP_FE2CL_REP_PC_NANO_CREATE_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_NANO_CREATE_SUCC, sizeof(sP_FE2CL_REP_PC_NANO_CREATE_SUCC), sock->getFEKey())); - // Update player - plr.Nanos[nanoId] = resp->Nano; - PlayerManager::updatePlayer(sock, plr); + // Update player + plr.Nanos[nanoId] = resp->Nano; + PlayerManager::updatePlayer(sock, plr); } void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) { - Player plr = PlayerManager::getPlayer(sock); - sNano nano = plr.Nanos[nanoId]; + Player plr = PlayerManager::getPlayer(sock); + sNano nano = plr.Nanos[nanoId]; - nano.iSkillID = skillId; - plr.Nanos[nanoId] = nano; + nano.iSkillID = skillId; + plr.Nanos[nanoId] = nano; - // Send to client - sP_FE2CL_REP_NANO_TUNE_SUCC* resp = (sP_FE2CL_REP_NANO_TUNE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC)); - resp->iNanoID = nanoId; - resp->iSkillID = skillId; + // Send to client + sP_FE2CL_REP_NANO_TUNE_SUCC* resp = (sP_FE2CL_REP_NANO_TUNE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC)); + resp->iNanoID = nanoId; + resp->iSkillID = skillId; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC), sock->getFEKey())); - std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl; + std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl; - // Update the player - PlayerManager::updatePlayer(sock, plr); + // Update the player + PlayerManager::updatePlayer(sock, plr); } void NanoManager::resetNanoSkill(CNSocket* sock, int16_t nanoId) { - Player plr = PlayerManager::getPlayer(sock); - sNano nano = plr.Nanos[nanoId]; + Player plr = PlayerManager::getPlayer(sock); + sNano nano = plr.Nanos[nanoId]; - nano.iSkillID = 0; - plr.Nanos[nanoId] = nano; + nano.iSkillID = 0; + plr.Nanos[nanoId] = nano; - // Update the player - PlayerManager::updatePlayer(sock, plr); + // Update the player + PlayerManager::updatePlayer(sock, plr); } #pragma endregion \ No newline at end of file diff --git a/src/NanoManager.hpp b/src/NanoManager.hpp index 942f63a..d1f2646 100644 --- a/src/NanoManager.hpp +++ b/src/NanoManager.hpp @@ -4,18 +4,18 @@ #include "CNShardServer.hpp" namespace NanoManager { - void init(); - void nanoSummonHandler(CNSocket* sock, CNPacketData* data); - void nanoEquipHandler(CNSocket* sock, CNPacketData* data); - void nanoUnEquipHandler(CNSocket* sock, CNPacketData* data); - void nanoGMGiveHandler(CNSocket* sock, CNPacketData* data); - void nanoSkillUseHandler(CNSocket* sock, CNPacketData* data); - void nanoSkillSetHandler(CNSocket* sock, CNPacketData* data); + void init(); + void nanoSummonHandler(CNSocket* sock, CNPacketData* data); + void nanoEquipHandler(CNSocket* sock, CNPacketData* data); + void nanoUnEquipHandler(CNSocket* sock, CNPacketData* data); + void nanoGMGiveHandler(CNSocket* sock, CNPacketData* data); + void nanoSkillUseHandler(CNSocket* sock, CNPacketData* data); + void nanoSkillSetHandler(CNSocket* sock, CNPacketData* data); - // Helper methods - void addNano(CNSocket* sock, int16_t nanoId, int16_t slot); - void setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId); - void resetNanoSkill(CNSocket* sock, int16_t nanoId); + // Helper methods + void addNano(CNSocket* sock, int16_t nanoId, int16_t slot); + void setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId); + void resetNanoSkill(CNSocket* sock, int16_t nanoId); } #endif \ No newline at end of file diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index 3018187..a074ee5 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -13,557 +13,557 @@ std::map PlayerManager::players; void PlayerManager::init() { - // register packet types - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_ENTER, PlayerManager::enterPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_LOADING_COMPLETE, PlayerManager::loadPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_MOVE, PlayerManager::movePlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_STOP, PlayerManager::stopPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_JUMP, PlayerManager::jumpPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_JUMPPAD, PlayerManager::jumppadPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_LAUNCHER, PlayerManager::launchPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_ZIPLINE, PlayerManager::ziplinePlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_MOVEPLATFORM, PlayerManager::movePlatformPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_SLOPE, PlayerManager::moveSlopePlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GOTO, PlayerManager::gotoPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_PC_SET_VALUE, PlayerManager::setSpecialPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REP_LIVE_CHECK, PlayerManager::heartbeatPlayer); - REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_EXIT, PlayerManager::exitGame); + // register packet types + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_ENTER, PlayerManager::enterPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_LOADING_COMPLETE, PlayerManager::loadPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_MOVE, PlayerManager::movePlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_STOP, PlayerManager::stopPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_JUMP, PlayerManager::jumpPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_JUMPPAD, PlayerManager::jumppadPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_LAUNCHER, PlayerManager::launchPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_ZIPLINE, PlayerManager::ziplinePlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_MOVEPLATFORM, PlayerManager::movePlatformPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_SLOPE, PlayerManager::moveSlopePlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GOTO, PlayerManager::gotoPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_PC_SET_VALUE, PlayerManager::setSpecialPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REP_LIVE_CHECK, PlayerManager::heartbeatPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_EXIT, PlayerManager::exitGame); } void PlayerManager::addPlayer(CNSocket* key, Player plr) { - players[key] = PlayerView(); - players[key].viewable = std::list(); - players[key].plr = plr; - players[key].lastHeartbeat = 0; + players[key] = PlayerView(); + players[key].viewable = std::list(); + players[key].plr = plr; + players[key].lastHeartbeat = 0; - std::cout << U16toU8(plr.PCStyle.szFirstName) << " " << U16toU8(plr.PCStyle.szLastName) << " has joined!" << std::endl; - std::cout << players.size() << " players" << std::endl; + std::cout << U16toU8(plr.PCStyle.szFirstName) << " " << U16toU8(plr.PCStyle.szLastName) << " has joined!" << std::endl; + std::cout << players.size() << " players" << std::endl; } void PlayerManager::removePlayer(CNSocket* key) { - PlayerView cachedView = players[key]; + PlayerView cachedView = players[key]; - // if players have them in their viewable lists, remove it - for (CNSocket* otherSock : players[key].viewable) { - players[otherSock].viewable.remove(key); // gone + // if players have them in their viewable lists, remove it + for (CNSocket* otherSock : players[key].viewable) { + players[otherSock].viewable.remove(key); // gone - // now sent PC_EXIT packet - sP_FE2CL_PC_EXIT* exitPacket = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); - exitPacket->iID = players[key].plr.iID; + // now sent PC_EXIT packet + sP_FE2CL_PC_EXIT* exitPacket = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); + exitPacket->iID = players[key].plr.iID; - otherSock->sendPacket(new CNPacketData((void*)exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), otherSock->getFEKey())); + } - players.erase(key); + players.erase(key); - std::cout << U16toU8(cachedView.plr.PCStyle.szFirstName) << U16toU8(cachedView.plr.PCStyle.szLastName) << " has left!" << std::endl; - std::cout << players.size() << " players" << std::endl; + std::cout << U16toU8(cachedView.plr.PCStyle.szFirstName) << U16toU8(cachedView.plr.PCStyle.szLastName) << " has left!" << std::endl; + std::cout << players.size() << " players" << std::endl; } Player PlayerManager::getPlayer(CNSocket* key) { - return players[key].plr; + return players[key].plr; } void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { - players[sock].plr.x = X; - players[sock].plr.y = Y; - players[sock].plr.z = Z; + players[sock].plr.x = X; + players[sock].plr.y = Y; + players[sock].plr.z = Z; - std::vector noView; - std::vector yesView; + std::vector noView; + std::vector yesView; - // TODO: oh god this is sooooo perfomance heavy the more players you have - for (auto pair : players) { - if (pair.first == sock) - continue; // ignore our own connection + // TODO: oh god this is sooooo perfomance heavy the more players you have + for (auto pair : players) { + if (pair.first == sock) + continue; // ignore our own connection - int diffX = abs(pair.second.plr.x - X); // the map is like a grid, X and Y are your position on the map, Z is the height. very different from other games... - int diffY = abs(pair.second.plr.y - Y); + int diffX = abs(pair.second.plr.x - X); // the map is like a grid, X and Y are your position on the map, Z is the height. very different from other games... + int diffY = abs(pair.second.plr.y - Y); - if (diffX < settings::VIEWDISTANCE && diffY < settings::VIEWDISTANCE) { - yesView.push_back(pair.first); - } - else { - noView.push_back(pair.first); - } - } + if (diffX < settings::VIEWDISTANCE && diffY < settings::VIEWDISTANCE) { + yesView.push_back(pair.first); + } + else { + noView.push_back(pair.first); + } + } - std::list::iterator i = players[sock].viewable.begin(); - while (i != players[sock].viewable.end()) { - CNSocket* otherSock = *i; - if (std::find(noView.begin(), noView.end(), otherSock) != noView.end()) { - // sock shouldn't be visible, send PC_EXIT packet & remove them + std::list::iterator i = players[sock].viewable.begin(); + while (i != players[sock].viewable.end()) { + CNSocket* otherSock = *i; + if (std::find(noView.begin(), noView.end(), otherSock) != noView.end()) { + // sock shouldn't be visible, send PC_EXIT packet & remove them - sP_FE2CL_PC_EXIT* exitPacket = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); - sP_FE2CL_PC_EXIT* exitPacketOther = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); + sP_FE2CL_PC_EXIT* exitPacket = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); + sP_FE2CL_PC_EXIT* exitPacketOther = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); - exitPacket->iID = players[sock].plr.iID; - exitPacketOther->iID = players[otherSock].plr.iID; + exitPacket->iID = players[sock].plr.iID; + exitPacketOther->iID = players[otherSock].plr.iID; - otherSock->sendPacket(new CNPacketData((void*)exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), otherSock->getFEKey())); - sock->sendPacket(new CNPacketData((void*)exitPacketOther, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), sock->getFEKey())); + otherSock->sendPacket(new CNPacketData((void*)exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), otherSock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)exitPacketOther, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), sock->getFEKey())); - players[sock].viewable.erase(i++); - players[otherSock].viewable.remove(sock); - continue; - } + players[sock].viewable.erase(i++); + players[otherSock].viewable.remove(sock); + continue; + } - ++i; - } + ++i; + } - for (CNSocket* otherSock : yesView) { - if (std::find(players[sock].viewable.begin(), players[sock].viewable.end(), otherSock) == players[sock].viewable.end()) { - // this needs to be added to the viewable players, send PC_ENTER + for (CNSocket* otherSock : yesView) { + if (std::find(players[sock].viewable.begin(), players[sock].viewable.end(), otherSock) == players[sock].viewable.end()) { + // this needs to be added to the viewable players, send PC_ENTER - sP_FE2CL_PC_NEW* newPlayer = (sP_FE2CL_PC_NEW*)xmalloc(sizeof(sP_FE2CL_PC_NEW)); // current connection to other player - sP_FE2CL_PC_NEW* newOtherPlayer = (sP_FE2CL_PC_NEW*)xmalloc(sizeof(sP_FE2CL_PC_NEW)); // other player to current connection + sP_FE2CL_PC_NEW* newPlayer = (sP_FE2CL_PC_NEW*)xmalloc(sizeof(sP_FE2CL_PC_NEW)); // current connection to other player + sP_FE2CL_PC_NEW* newOtherPlayer = (sP_FE2CL_PC_NEW*)xmalloc(sizeof(sP_FE2CL_PC_NEW)); // other player to current connection - Player otherPlr = players[otherSock].plr; - Player plr = players[sock].plr; + Player otherPlr = players[otherSock].plr; + Player plr = players[sock].plr; - newPlayer->PCAppearanceData.iID = plr.iID; - newPlayer->PCAppearanceData.iHP = plr.HP; - newPlayer->PCAppearanceData.iLv = plr.level; - newPlayer->PCAppearanceData.iX = plr.x; - newPlayer->PCAppearanceData.iY = plr.y; - newPlayer->PCAppearanceData.iZ = plr.z; - newPlayer->PCAppearanceData.iAngle = plr.angle; - newPlayer->PCAppearanceData.PCStyle = plr.PCStyle; - memcpy(newPlayer->PCAppearanceData.ItemEquip, plr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); + newPlayer->PCAppearanceData.iID = plr.iID; + newPlayer->PCAppearanceData.iHP = plr.HP; + newPlayer->PCAppearanceData.iLv = plr.level; + newPlayer->PCAppearanceData.iX = plr.x; + newPlayer->PCAppearanceData.iY = plr.y; + newPlayer->PCAppearanceData.iZ = plr.z; + newPlayer->PCAppearanceData.iAngle = plr.angle; + newPlayer->PCAppearanceData.PCStyle = plr.PCStyle; + memcpy(newPlayer->PCAppearanceData.ItemEquip, plr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); - newOtherPlayer->PCAppearanceData.iID = otherPlr.iID; - newOtherPlayer->PCAppearanceData.iHP = otherPlr.HP; - newOtherPlayer->PCAppearanceData.iLv = otherPlr.level; - newOtherPlayer->PCAppearanceData.iX = otherPlr.x; - newOtherPlayer->PCAppearanceData.iY = otherPlr.y; - newOtherPlayer->PCAppearanceData.iZ = otherPlr.z; - newOtherPlayer->PCAppearanceData.iAngle = otherPlr.angle; - newOtherPlayer->PCAppearanceData.PCStyle = otherPlr.PCStyle; - memcpy(newOtherPlayer->PCAppearanceData.ItemEquip, otherPlr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); + newOtherPlayer->PCAppearanceData.iID = otherPlr.iID; + newOtherPlayer->PCAppearanceData.iHP = otherPlr.HP; + newOtherPlayer->PCAppearanceData.iLv = otherPlr.level; + newOtherPlayer->PCAppearanceData.iX = otherPlr.x; + newOtherPlayer->PCAppearanceData.iY = otherPlr.y; + newOtherPlayer->PCAppearanceData.iZ = otherPlr.z; + newOtherPlayer->PCAppearanceData.iAngle = otherPlr.angle; + newOtherPlayer->PCAppearanceData.PCStyle = otherPlr.PCStyle; + memcpy(newOtherPlayer->PCAppearanceData.ItemEquip, otherPlr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); - sock->sendPacket(new CNPacketData((void*)newOtherPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW), sock->getFEKey())); - otherSock->sendPacket(new CNPacketData((void*)newPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW), otherSock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)newOtherPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW), sock->getFEKey())); + otherSock->sendPacket(new CNPacketData((void*)newPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW), otherSock->getFEKey())); - players[sock].viewable.push_back(otherSock); - players[otherSock].viewable.push_back(sock); - } - } + players[sock].viewable.push_back(otherSock); + players[otherSock].viewable.push_back(sock); + } + } - NPCManager::updatePlayerNPCS(sock, players[sock]); + NPCManager::updatePlayerNPCS(sock, players[sock]); } void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_ENTER)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_ENTER)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_ENTER* enter = (sP_CL2FE_REQ_PC_ENTER*)data->buf; - sP_FE2CL_REP_PC_ENTER_SUCC* response = (sP_FE2CL_REP_PC_ENTER_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_ENTER_SUCC)); - sP_FE2CL_PC_MOTD_LOGIN* motd = (sP_FE2CL_PC_MOTD_LOGIN*)xmalloc(sizeof(sP_FE2CL_PC_MOTD_LOGIN)); + sP_CL2FE_REQ_PC_ENTER* enter = (sP_CL2FE_REQ_PC_ENTER*)data->buf; + sP_FE2CL_REP_PC_ENTER_SUCC* response = (sP_FE2CL_REP_PC_ENTER_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_ENTER_SUCC)); + sP_FE2CL_PC_MOTD_LOGIN* motd = (sP_FE2CL_PC_MOTD_LOGIN*)xmalloc(sizeof(sP_FE2CL_PC_MOTD_LOGIN)); - // TODO: check if serialkey exists, if it doesn't send sP_FE2CL_REP_PC_ENTER_FAIL - Player plr = CNSharedData::getPlayer(enter->iEnterSerialKey); + // TODO: check if serialkey exists, if it doesn't send sP_FE2CL_REP_PC_ENTER_FAIL + Player plr = CNSharedData::getPlayer(enter->iEnterSerialKey); - DEBUGLOG( - std::cout << "P_CL2FE_REQ_PC_ENTER:" << std::endl; - std::cout << "\tID: " << U16toU8(enter->szID) << std::endl; - std::cout << "\tSerial: " << enter->iEnterSerialKey << std::endl; - std::cout << "\tTemp: " << enter->iTempValue << std::endl; - std::cout << "\tPC_UID: " << plr.PCStyle.iPC_UID << std::endl; - ) + DEBUGLOG( + std::cout << "P_CL2FE_REQ_PC_ENTER:" << std::endl; + std::cout << "\tID: " << U16toU8(enter->szID) << std::endl; + std::cout << "\tSerial: " << enter->iEnterSerialKey << std::endl; + std::cout << "\tTemp: " << enter->iTempValue << std::endl; + std::cout << "\tPC_UID: " << plr.PCStyle.iPC_UID << std::endl; + ) - response->iID = rand(); - response->uiSvrTime = getTime(); - response->PCLoadData2CL.iUserLevel = 1; - response->PCLoadData2CL.iHP = 1000 * plr.level; - response->PCLoadData2CL.iLevel = plr.level; - response->PCLoadData2CL.iMentor = 1; - response->PCLoadData2CL.iMentorCount = 4; - response->PCLoadData2CL.iMapNum = 0; - response->PCLoadData2CL.iX = plr.x; - response->PCLoadData2CL.iY = plr.y; - response->PCLoadData2CL.iZ = plr.z; - response->PCLoadData2CL.iActiveNanoSlotNum = -1; - response->PCLoadData2CL.iFatigue = 50; - response->PCLoadData2CL.PCStyle = plr.PCStyle; - response->PCLoadData2CL.PCStyle2 = plr.PCStyle2; + response->iID = rand(); + response->uiSvrTime = getTime(); + response->PCLoadData2CL.iUserLevel = 1; + response->PCLoadData2CL.iHP = 1000 * plr.level; + response->PCLoadData2CL.iLevel = plr.level; + response->PCLoadData2CL.iMentor = 1; + response->PCLoadData2CL.iMentorCount = 4; + response->PCLoadData2CL.iMapNum = 0; + response->PCLoadData2CL.iX = plr.x; + response->PCLoadData2CL.iY = plr.y; + response->PCLoadData2CL.iZ = plr.z; + response->PCLoadData2CL.iActiveNanoSlotNum = -1; + response->PCLoadData2CL.iFatigue = 50; + response->PCLoadData2CL.PCStyle = plr.PCStyle; + response->PCLoadData2CL.PCStyle2 = plr.PCStyle2; - for (int i = 0; i < AEQUIP_COUNT; i++) - response->PCLoadData2CL.aEquip[i] = plr.Equip[i]; + for (int i = 0; i < AEQUIP_COUNT; i++) + response->PCLoadData2CL.aEquip[i] = plr.Equip[i]; - // protocol-agnostic sItemBase usage - sItemBase item; - memset(&item, 0, sizeof(sItemBase)); - item.iID = 495; + // protocol-agnostic sItemBase usage + sItemBase item; + memset(&item, 0, sizeof(sItemBase)); + item.iID = 495; - for (int i = 0; i < AINVEN_COUNT; i++) { - switch (i) { - case 6: case 8: case 11: case 13: case 20: - case 24: case 26: case 27: case 28: - plr.Inven[i] = item; - break; - default: - memset(&plr.Inven[i], 0, sizeof(sItemBase)); - } - response->PCLoadData2CL.aInven[i] = plr.Inven[i]; - } + for (int i = 0; i < AINVEN_COUNT; i++) { + switch (i) { + case 6: case 8: case 11: case 13: case 20: + case 24: case 26: case 27: case 28: + plr.Inven[i] = item; + break; + default: + memset(&plr.Inven[i], 0, sizeof(sItemBase)); + } + response->PCLoadData2CL.aInven[i] = plr.Inven[i]; + } - // don't ask.. - for (int i = 1; i < 37; i++) { - response->PCLoadData2CL.aNanoBank[i].iID = i; - response->PCLoadData2CL.aNanoBank[i].iSkillID = 1; - response->PCLoadData2CL.aNanoBank[i].iStamina = 150; - } + // don't ask.. + for (int i = 1; i < 37; i++) { + response->PCLoadData2CL.aNanoBank[i].iID = i; + response->PCLoadData2CL.aNanoBank[i].iSkillID = 1; + response->PCLoadData2CL.aNanoBank[i].iStamina = 150; + } - //response->PCLoadData2CL.aNanoSlots[0] = 1; - //response->PCLoadData2CL.aNanoSlots[1] = 2; - //response->PCLoadData2CL.aNanoSlots[2] = 3; + //response->PCLoadData2CL.aNanoSlots[0] = 1; + //response->PCLoadData2CL.aNanoSlots[1] = 2; + //response->PCLoadData2CL.aNanoSlots[2] = 3; - response->PCLoadData2CL.aQuestFlag[0] = -1; + response->PCLoadData2CL.aQuestFlag[0] = -1; - plr.iID = response->iID; - plr.SerialKey = enter->iEnterSerialKey; - plr.HP = response->PCLoadData2CL.iHP; + plr.iID = response->iID; + plr.SerialKey = enter->iEnterSerialKey; + plr.HP = response->PCLoadData2CL.iHP; - motd->iType = 1; - U8toU16(settings::MOTDSTRING, (char16_t*)motd->szSystemMsg); + motd->iType = 1; + U8toU16(settings::MOTDSTRING, (char16_t*)motd->szSystemMsg); - sock->setEKey(CNSocketEncryption::createNewKey(response->uiSvrTime, response->iID + 1, response->PCLoadData2CL.iFusionMatter + 1)); - sock->setFEKey(plr.FEKey); + sock->setEKey(CNSocketEncryption::createNewKey(response->uiSvrTime, response->iID + 1, response->PCLoadData2CL.iFusionMatter + 1)); + sock->setFEKey(plr.FEKey); - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_ENTER_SUCC, sizeof(sP_FE2CL_REP_PC_ENTER_SUCC), sock->getFEKey())); - // transmit MOTD after entering the game, so the client hopefully changes modes on time - sock->sendPacket(new CNPacketData((void*)motd, P_FE2CL_PC_MOTD_LOGIN, sizeof(sP_FE2CL_PC_MOTD_LOGIN), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_ENTER_SUCC, sizeof(sP_FE2CL_REP_PC_ENTER_SUCC), sock->getFEKey())); + // transmit MOTD after entering the game, so the client hopefully changes modes on time + sock->sendPacket(new CNPacketData((void*)motd, P_FE2CL_PC_MOTD_LOGIN, sizeof(sP_FE2CL_PC_MOTD_LOGIN), sock->getFEKey())); - addPlayer(sock, plr); + addPlayer(sock, plr); } void PlayerManager::loadPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_LOADING_COMPLETE)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_LOADING_COMPLETE)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_LOADING_COMPLETE* complete = (sP_CL2FE_REQ_PC_LOADING_COMPLETE*)data->buf; - sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC* response = (sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC)); + sP_CL2FE_REQ_PC_LOADING_COMPLETE* complete = (sP_CL2FE_REQ_PC_LOADING_COMPLETE*)data->buf; + sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC* response = (sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC)); - DEBUGLOG( - std::cout << "P_CL2FE_REQ_PC_LOADING_COMPLETE:" << std::endl; - std::cout << "\tPC_ID: " << complete->iPC_ID << std::endl; - ) + DEBUGLOG( + std::cout << "P_CL2FE_REQ_PC_LOADING_COMPLETE:" << std::endl; + std::cout << "\tPC_ID: " << complete->iPC_ID << std::endl; + ) - response->iPC_ID = complete->iPC_ID; + response->iPC_ID = complete->iPC_ID; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC), sock->getFEKey())); } void PlayerManager::movePlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_MOVE)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_MOVE)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_MOVE* moveData = (sP_CL2FE_REQ_PC_MOVE*)data->buf; - updatePlayerPosition(sock, moveData->iX, moveData->iY, moveData->iZ); + sP_CL2FE_REQ_PC_MOVE* moveData = (sP_CL2FE_REQ_PC_MOVE*)data->buf; + updatePlayerPosition(sock, moveData->iX, moveData->iY, moveData->iZ); - players[sock].plr.angle = moveData->iAngle; - uint64_t tm = getTime(); + players[sock].plr.angle = moveData->iAngle; + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_MOVE* moveResponse = (sP_FE2CL_PC_MOVE*)xmalloc(sizeof(sP_FE2CL_PC_MOVE)); + for (CNSocket* otherSock : players[sock].viewable) { + sP_FE2CL_PC_MOVE* moveResponse = (sP_FE2CL_PC_MOVE*)xmalloc(sizeof(sP_FE2CL_PC_MOVE)); - moveResponse->iID = players[sock].plr.iID; - moveResponse->cKeyValue = moveData->cKeyValue; + moveResponse->iID = players[sock].plr.iID; + moveResponse->cKeyValue = moveData->cKeyValue; - moveResponse->iX = moveData->iX; - moveResponse->iY = moveData->iY; - moveResponse->iZ = moveData->iZ; - moveResponse->iAngle = moveData->iAngle; - moveResponse->fVX = moveData->fVX; - moveResponse->fVY = moveData->fVY; - moveResponse->fVZ = moveData->fVZ; + moveResponse->iX = moveData->iX; + moveResponse->iY = moveData->iY; + moveResponse->iZ = moveData->iZ; + moveResponse->iAngle = moveData->iAngle; + moveResponse->fVX = moveData->fVX; + moveResponse->fVY = moveData->fVY; + moveResponse->fVZ = moveData->fVZ; - moveResponse->iSpeed = moveData->iSpeed; - moveResponse->iCliTime = moveData->iCliTime; // maybe don't send this??? seems unneeded... - moveResponse->iSvrTime = tm; + moveResponse->iSpeed = moveData->iSpeed; + moveResponse->iCliTime = moveData->iCliTime; // maybe don't send this??? seems unneeded... + moveResponse->iSvrTime = tm; - otherSock->sendPacket(new CNPacketData((void*)moveResponse, P_FE2CL_PC_MOVE, sizeof(sP_FE2CL_PC_MOVE), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)moveResponse, P_FE2CL_PC_MOVE, sizeof(sP_FE2CL_PC_MOVE), otherSock->getFEKey())); + } } void PlayerManager::stopPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_STOP)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_STOP)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_STOP* stopData = (sP_CL2FE_REQ_PC_STOP*)data->buf; - updatePlayerPosition(sock, stopData->iX, stopData->iY, stopData->iZ); + sP_CL2FE_REQ_PC_STOP* stopData = (sP_CL2FE_REQ_PC_STOP*)data->buf; + updatePlayerPosition(sock, stopData->iX, stopData->iY, stopData->iZ); - uint64_t tm = getTime(); + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_STOP* stopResponse = (sP_FE2CL_PC_STOP*)xmalloc(sizeof(sP_FE2CL_PC_STOP)); + for (CNSocket* otherSock : players[sock].viewable) { + sP_FE2CL_PC_STOP* stopResponse = (sP_FE2CL_PC_STOP*)xmalloc(sizeof(sP_FE2CL_PC_STOP)); - stopResponse->iID = players[sock].plr.iID; + stopResponse->iID = players[sock].plr.iID; - stopResponse->iX = stopData->iX; - stopResponse->iY = stopData->iY; - stopResponse->iZ = stopData->iZ; + stopResponse->iX = stopData->iX; + stopResponse->iY = stopData->iY; + stopResponse->iZ = stopData->iZ; - stopResponse->iCliTime = stopData->iCliTime; // maybe don't send this??? seems unneeded... - stopResponse->iSvrTime = tm; + stopResponse->iCliTime = stopData->iCliTime; // maybe don't send this??? seems unneeded... + stopResponse->iSvrTime = tm; - otherSock->sendPacket(new CNPacketData((void*)stopResponse, P_FE2CL_PC_STOP, sizeof(sP_FE2CL_PC_STOP), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)stopResponse, P_FE2CL_PC_STOP, sizeof(sP_FE2CL_PC_STOP), otherSock->getFEKey())); + } } void PlayerManager::jumpPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_JUMP)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_JUMP)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_JUMP* jumpData = (sP_CL2FE_REQ_PC_JUMP*)data->buf; - updatePlayerPosition(sock, jumpData->iX, jumpData->iY, jumpData->iZ); + sP_CL2FE_REQ_PC_JUMP* jumpData = (sP_CL2FE_REQ_PC_JUMP*)data->buf; + updatePlayerPosition(sock, jumpData->iX, jumpData->iY, jumpData->iZ); - uint64_t tm = getTime(); + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_JUMP* jumpResponse = (sP_FE2CL_PC_JUMP*)xmalloc(sizeof(sP_FE2CL_PC_JUMP)); + for (CNSocket* otherSock : players[sock].viewable) { + sP_FE2CL_PC_JUMP* jumpResponse = (sP_FE2CL_PC_JUMP*)xmalloc(sizeof(sP_FE2CL_PC_JUMP)); - jumpResponse->iID = players[sock].plr.iID; - jumpResponse->cKeyValue = jumpData->cKeyValue; + jumpResponse->iID = players[sock].plr.iID; + jumpResponse->cKeyValue = jumpData->cKeyValue; - jumpResponse->iX = jumpData->iX; - jumpResponse->iY = jumpData->iY; - jumpResponse->iZ = jumpData->iZ; - jumpResponse->iAngle = jumpData->iAngle; - jumpResponse->iVX = jumpData->iVX; - jumpResponse->iVY = jumpData->iVY; - jumpResponse->iVZ = jumpData->iVZ; + jumpResponse->iX = jumpData->iX; + jumpResponse->iY = jumpData->iY; + jumpResponse->iZ = jumpData->iZ; + jumpResponse->iAngle = jumpData->iAngle; + jumpResponse->iVX = jumpData->iVX; + jumpResponse->iVY = jumpData->iVY; + jumpResponse->iVZ = jumpData->iVZ; - jumpResponse->iSpeed = jumpData->iSpeed; - jumpResponse->iCliTime = jumpData->iCliTime; // maybe don't send this??? seems unneeded... - jumpResponse->iSvrTime = tm; + jumpResponse->iSpeed = jumpData->iSpeed; + jumpResponse->iCliTime = jumpData->iCliTime; // maybe don't send this??? seems unneeded... + jumpResponse->iSvrTime = tm; - otherSock->sendPacket(new CNPacketData((void*)jumpResponse, P_FE2CL_PC_JUMP, sizeof(sP_FE2CL_PC_JUMP), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)jumpResponse, P_FE2CL_PC_JUMP, sizeof(sP_FE2CL_PC_JUMP), otherSock->getFEKey())); + } } void PlayerManager::jumppadPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_JUMPPAD)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_JUMPPAD)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_JUMPPAD* jumppadData = (sP_CL2FE_REQ_PC_JUMPPAD*)data->buf; - updatePlayerPosition(sock, jumppadData->iX, jumppadData->iY, jumppadData->iZ); + sP_CL2FE_REQ_PC_JUMPPAD* jumppadData = (sP_CL2FE_REQ_PC_JUMPPAD*)data->buf; + updatePlayerPosition(sock, jumppadData->iX, jumppadData->iY, jumppadData->iZ); - uint64_t tm = getTime(); + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_JUMPPAD* jumppadResponse = (sP_FE2CL_PC_JUMPPAD*)xmalloc(sizeof(sP_FE2CL_PC_JUMPPAD)); + for (CNSocket* otherSock : players[sock].viewable) { + sP_FE2CL_PC_JUMPPAD* jumppadResponse = (sP_FE2CL_PC_JUMPPAD*)xmalloc(sizeof(sP_FE2CL_PC_JUMPPAD)); - jumppadResponse->iPC_ID = players[sock].plr.iID; - jumppadResponse->cKeyValue = jumppadData->cKeyValue; + jumppadResponse->iPC_ID = players[sock].plr.iID; + jumppadResponse->cKeyValue = jumppadData->cKeyValue; - jumppadResponse->iX = jumppadData->iX; - jumppadResponse->iY = jumppadData->iY; - jumppadResponse->iZ = jumppadData->iZ; - jumppadResponse->iVX = jumppadData->iVX; - jumppadResponse->iVY = jumppadData->iVY; - jumppadResponse->iVZ = jumppadData->iVZ; + jumppadResponse->iX = jumppadData->iX; + jumppadResponse->iY = jumppadData->iY; + jumppadResponse->iZ = jumppadData->iZ; + jumppadResponse->iVX = jumppadData->iVX; + jumppadResponse->iVY = jumppadData->iVY; + jumppadResponse->iVZ = jumppadData->iVZ; - jumppadResponse->iCliTime = jumppadData->iCliTime; - jumppadResponse->iSvrTime = tm; + jumppadResponse->iCliTime = jumppadData->iCliTime; + jumppadResponse->iSvrTime = tm; - otherSock->sendPacket(new CNPacketData((void*)jumppadResponse, P_FE2CL_PC_JUMPPAD, sizeof(sP_FE2CL_PC_JUMPPAD), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)jumppadResponse, P_FE2CL_PC_JUMPPAD, sizeof(sP_FE2CL_PC_JUMPPAD), otherSock->getFEKey())); + } } void PlayerManager::launchPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_LAUNCHER)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_LAUNCHER)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_LAUNCHER* launchData = (sP_CL2FE_REQ_PC_LAUNCHER*)data->buf; - updatePlayerPosition(sock, launchData->iX, launchData->iY, launchData->iZ); + sP_CL2FE_REQ_PC_LAUNCHER* launchData = (sP_CL2FE_REQ_PC_LAUNCHER*)data->buf; + updatePlayerPosition(sock, launchData->iX, launchData->iY, launchData->iZ); - uint64_t tm = getTime(); + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_LAUNCHER* launchResponse = (sP_FE2CL_PC_LAUNCHER*)xmalloc(sizeof(sP_FE2CL_PC_LAUNCHER)); + for (CNSocket* otherSock : players[sock].viewable) { + sP_FE2CL_PC_LAUNCHER* launchResponse = (sP_FE2CL_PC_LAUNCHER*)xmalloc(sizeof(sP_FE2CL_PC_LAUNCHER)); - launchResponse->iPC_ID = players[sock].plr.iID; + launchResponse->iPC_ID = players[sock].plr.iID; - launchResponse->iX = launchData->iX; - launchResponse->iY = launchData->iY; - launchResponse->iZ = launchData->iZ; - launchResponse->iVX = launchData->iVX; - launchResponse->iVY = launchData->iVY; - launchResponse->iVZ = launchData->iVZ; - launchResponse->iSpeed = launchData->iSpeed; - launchResponse->iAngle = launchData->iAngle; + launchResponse->iX = launchData->iX; + launchResponse->iY = launchData->iY; + launchResponse->iZ = launchData->iZ; + launchResponse->iVX = launchData->iVX; + launchResponse->iVY = launchData->iVY; + launchResponse->iVZ = launchData->iVZ; + launchResponse->iSpeed = launchData->iSpeed; + launchResponse->iAngle = launchData->iAngle; - launchResponse->iCliTime = launchData->iCliTime; - launchResponse->iSvrTime = tm; + launchResponse->iCliTime = launchData->iCliTime; + launchResponse->iSvrTime = tm; - otherSock->sendPacket(new CNPacketData((void*)launchResponse, P_FE2CL_PC_LAUNCHER, sizeof(sP_FE2CL_PC_LAUNCHER), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)launchResponse, P_FE2CL_PC_LAUNCHER, sizeof(sP_FE2CL_PC_LAUNCHER), otherSock->getFEKey())); + } } void PlayerManager::ziplinePlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_ZIPLINE)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_ZIPLINE)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_ZIPLINE* ziplineData = (sP_CL2FE_REQ_PC_ZIPLINE*)data->buf; - updatePlayerPosition(sock, ziplineData->iX, ziplineData->iY, ziplineData->iZ); + sP_CL2FE_REQ_PC_ZIPLINE* ziplineData = (sP_CL2FE_REQ_PC_ZIPLINE*)data->buf; + updatePlayerPosition(sock, ziplineData->iX, ziplineData->iY, ziplineData->iZ); - uint64_t tm = getTime(); + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_ZIPLINE* ziplineResponse = (sP_FE2CL_PC_ZIPLINE*)xmalloc(sizeof(sP_FE2CL_PC_ZIPLINE)); + sP_FE2CL_PC_ZIPLINE* ziplineResponse = (sP_FE2CL_PC_ZIPLINE*)xmalloc(sizeof(sP_FE2CL_PC_ZIPLINE)); - ziplineResponse->iPC_ID = players[sock].plr.iID; - ziplineResponse->iCliTime = ziplineData->iCliTime; - ziplineResponse->iSvrTime = tm; - ziplineResponse->iX = ziplineData->iX; - ziplineResponse->iY = ziplineData->iY; - ziplineResponse->iZ = ziplineData->iZ; - ziplineResponse->fVX = ziplineData->fVX; - ziplineResponse->fVY = ziplineData->fVY; - ziplineResponse->fVZ = ziplineData->fVZ; - ziplineResponse->fMovDistance = ziplineData->fMovDistance; - ziplineResponse->fMaxDistance = ziplineData->fMaxDistance; - ziplineResponse->fDummy = ziplineData->fDummy; //wtf is this for? - ziplineResponse->iStX = ziplineData->iStX; - ziplineResponse->iStY = ziplineData->iStY; - ziplineResponse->iStZ = ziplineData->iStZ; - ziplineResponse->bDown = ziplineData->bDown; - ziplineResponse->iSpeed = ziplineData->iSpeed; - ziplineResponse->iAngle = ziplineData->iAngle; - ziplineResponse->iRollMax = ziplineData->iRollMax; - ziplineResponse->iRoll = ziplineData->iRoll; + ziplineResponse->iPC_ID = players[sock].plr.iID; + ziplineResponse->iCliTime = ziplineData->iCliTime; + ziplineResponse->iSvrTime = tm; + ziplineResponse->iX = ziplineData->iX; + ziplineResponse->iY = ziplineData->iY; + ziplineResponse->iZ = ziplineData->iZ; + ziplineResponse->fVX = ziplineData->fVX; + ziplineResponse->fVY = ziplineData->fVY; + ziplineResponse->fVZ = ziplineData->fVZ; + ziplineResponse->fMovDistance = ziplineData->fMovDistance; + ziplineResponse->fMaxDistance = ziplineData->fMaxDistance; + ziplineResponse->fDummy = ziplineData->fDummy; //wtf is this for? + ziplineResponse->iStX = ziplineData->iStX; + ziplineResponse->iStY = ziplineData->iStY; + ziplineResponse->iStZ = ziplineData->iStZ; + ziplineResponse->bDown = ziplineData->bDown; + ziplineResponse->iSpeed = ziplineData->iSpeed; + ziplineResponse->iAngle = ziplineData->iAngle; + ziplineResponse->iRollMax = ziplineData->iRollMax; + ziplineResponse->iRoll = ziplineData->iRoll; - otherSock->sendPacket(new CNPacketData((void*)ziplineResponse, P_FE2CL_PC_ZIPLINE, sizeof(sP_FE2CL_PC_ZIPLINE), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)ziplineResponse, P_FE2CL_PC_ZIPLINE, sizeof(sP_FE2CL_PC_ZIPLINE), otherSock->getFEKey())); + } } void PlayerManager::movePlatformPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_MOVEPLATFORM)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_MOVEPLATFORM)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_MOVEPLATFORM* platformData = (sP_CL2FE_REQ_PC_MOVEPLATFORM*)data->buf; - updatePlayerPosition(sock, platformData->iX, platformData->iY, platformData->iZ); + sP_CL2FE_REQ_PC_MOVEPLATFORM* platformData = (sP_CL2FE_REQ_PC_MOVEPLATFORM*)data->buf; + updatePlayerPosition(sock, platformData->iX, platformData->iY, platformData->iZ); - uint64_t tm = getTime(); + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_MOVEPLATFORM* platResponse = (sP_FE2CL_PC_MOVEPLATFORM*)xmalloc(sizeof(sP_FE2CL_PC_MOVEPLATFORM)); + sP_FE2CL_PC_MOVEPLATFORM* platResponse = (sP_FE2CL_PC_MOVEPLATFORM*)xmalloc(sizeof(sP_FE2CL_PC_MOVEPLATFORM)); - platResponse->iPC_ID = players[sock].plr.iID; - platResponse->iCliTime = platformData->iCliTime; - platResponse->iSvrTime = tm; - platResponse->iX = platformData->iX; - platResponse->iY = platformData->iY; - platResponse->iZ = platformData->iZ; - platResponse->iAngle = platformData->iAngle; - platResponse->fVX = platformData->fVX; - platResponse->fVY = platformData->fVY; - platResponse->fVZ = platformData->fVZ; - platResponse->iLcX = platformData->iLcX; - platResponse->iLcY = platformData->iLcY; - platResponse->iLcZ = platformData->iLcZ; - platResponse->iSpeed = platformData->iSpeed; - platResponse->bDown = platformData->bDown; - platResponse->cKeyValue = platformData->cKeyValue; - platResponse->iPlatformID = platformData->iPlatformID; + platResponse->iPC_ID = players[sock].plr.iID; + platResponse->iCliTime = platformData->iCliTime; + platResponse->iSvrTime = tm; + platResponse->iX = platformData->iX; + platResponse->iY = platformData->iY; + platResponse->iZ = platformData->iZ; + platResponse->iAngle = platformData->iAngle; + platResponse->fVX = platformData->fVX; + platResponse->fVY = platformData->fVY; + platResponse->fVZ = platformData->fVZ; + platResponse->iLcX = platformData->iLcX; + platResponse->iLcY = platformData->iLcY; + platResponse->iLcZ = platformData->iLcZ; + platResponse->iSpeed = platformData->iSpeed; + platResponse->bDown = platformData->bDown; + platResponse->cKeyValue = platformData->cKeyValue; + platResponse->iPlatformID = platformData->iPlatformID; - otherSock->sendPacket(new CNPacketData((void*)platResponse, P_FE2CL_PC_MOVEPLATFORM, sizeof(sP_FE2CL_PC_MOVEPLATFORM), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)platResponse, P_FE2CL_PC_MOVEPLATFORM, sizeof(sP_FE2CL_PC_MOVEPLATFORM), otherSock->getFEKey())); + } } void PlayerManager::moveSlopePlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_SLOPE)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_SLOPE)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_SLOPE* slopeData = (sP_CL2FE_REQ_PC_SLOPE*)data->buf; - updatePlayerPosition(sock, slopeData->iX, slopeData->iY, slopeData->iZ); + sP_CL2FE_REQ_PC_SLOPE* slopeData = (sP_CL2FE_REQ_PC_SLOPE*)data->buf; + updatePlayerPosition(sock, slopeData->iX, slopeData->iY, slopeData->iZ); - uint64_t tm = getTime(); + uint64_t tm = getTime(); - for (CNSocket* otherSock : players[sock].viewable) { + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_SLOPE* slopeResponse = (sP_FE2CL_PC_SLOPE*)xmalloc(sizeof(sP_FE2CL_PC_SLOPE)); + sP_FE2CL_PC_SLOPE* slopeResponse = (sP_FE2CL_PC_SLOPE*)xmalloc(sizeof(sP_FE2CL_PC_SLOPE)); - slopeResponse->iPC_ID = players[sock].plr.iID; - slopeResponse->iCliTime = slopeData->iCliTime; - slopeResponse->iSvrTime = tm; - slopeResponse->iX = slopeData->iX; - slopeResponse->iY = slopeData->iY; - slopeResponse->iZ = slopeData->iZ; - slopeResponse->iAngle = slopeData->iAngle; - slopeResponse->fVX = slopeData->fVX; - slopeResponse->fVY = slopeData->fVY; - slopeResponse->fVZ = slopeData->fVZ; - slopeResponse->iSpeed = slopeData->iSpeed; - slopeResponse->cKeyValue = slopeData->cKeyValue; - slopeResponse->iSlopeID = slopeData->iSlopeID; + slopeResponse->iPC_ID = players[sock].plr.iID; + slopeResponse->iCliTime = slopeData->iCliTime; + slopeResponse->iSvrTime = tm; + slopeResponse->iX = slopeData->iX; + slopeResponse->iY = slopeData->iY; + slopeResponse->iZ = slopeData->iZ; + slopeResponse->iAngle = slopeData->iAngle; + slopeResponse->fVX = slopeData->fVX; + slopeResponse->fVY = slopeData->fVY; + slopeResponse->fVZ = slopeData->fVZ; + slopeResponse->iSpeed = slopeData->iSpeed; + slopeResponse->cKeyValue = slopeData->cKeyValue; + slopeResponse->iSlopeID = slopeData->iSlopeID; - otherSock->sendPacket(new CNPacketData((void*)slopeResponse, P_FE2CL_PC_SLOPE, sizeof(sP_FE2CL_PC_SLOPE), otherSock->getFEKey())); - } + otherSock->sendPacket(new CNPacketData((void*)slopeResponse, P_FE2CL_PC_SLOPE, sizeof(sP_FE2CL_PC_SLOPE), otherSock->getFEKey())); + } } void PlayerManager::gotoPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_REQ_PC_GOTO)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_REQ_PC_GOTO)) + return; // ignore the malformed packet - sP_CL2FE_REQ_PC_GOTO* gotoData = (sP_CL2FE_REQ_PC_GOTO*)data->buf; - sP_FE2CL_REP_PC_GOTO_SUCC* response = (sP_FE2CL_REP_PC_GOTO_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_GOTO_SUCC)); + sP_CL2FE_REQ_PC_GOTO* gotoData = (sP_CL2FE_REQ_PC_GOTO*)data->buf; + sP_FE2CL_REP_PC_GOTO_SUCC* response = (sP_FE2CL_REP_PC_GOTO_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_GOTO_SUCC)); - DEBUGLOG( - std::cout << "P_CL2FE_REQ_PC_GOTO:" << std::endl; - std::cout << "\tX: " << gotoData->iToX << std::endl; - std::cout << "\tY: " << gotoData->iToY << std::endl; - std::cout << "\tZ: " << gotoData->iToZ << std::endl; - ) + DEBUGLOG( + std::cout << "P_CL2FE_REQ_PC_GOTO:" << std::endl; + std::cout << "\tX: " << gotoData->iToX << std::endl; + std::cout << "\tY: " << gotoData->iToY << std::endl; + std::cout << "\tZ: " << gotoData->iToZ << std::endl; + ) - response->iX = gotoData->iToX; - response->iY = gotoData->iToY; - response->iZ = gotoData->iToZ; + response->iX = gotoData->iToX; + response->iY = gotoData->iToY; + response->iZ = gotoData->iToZ; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_GOTO_SUCC, sizeof(sP_FE2CL_REP_PC_GOTO_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_GOTO_SUCC, sizeof(sP_FE2CL_REP_PC_GOTO_SUCC), sock->getFEKey())); } void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) { - if (data->size != sizeof(sP_CL2FE_GM_REQ_PC_SET_VALUE)) - return; // ignore the malformed packet + if (data->size != sizeof(sP_CL2FE_GM_REQ_PC_SET_VALUE)) + return; // ignore the malformed packet - sP_CL2FE_GM_REQ_PC_SET_VALUE* setData = (sP_CL2FE_GM_REQ_PC_SET_VALUE*)data->buf; - sP_FE2CL_GM_REP_PC_SET_VALUE* response = (sP_FE2CL_GM_REP_PC_SET_VALUE*)xmalloc(sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE)); + sP_CL2FE_GM_REQ_PC_SET_VALUE* setData = (sP_CL2FE_GM_REQ_PC_SET_VALUE*)data->buf; + sP_FE2CL_GM_REP_PC_SET_VALUE* response = (sP_FE2CL_GM_REP_PC_SET_VALUE*)xmalloc(sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE)); - DEBUGLOG( - std::cout << "P_CL2FE_GM_REQ_PC_SET_VALUE:" << std::endl; - std::cout << "\tPC_ID: " << setData->iPC_ID << std::endl; - std::cout << "\tSetValueType: " << setData->iSetValueType << std::endl; - std::cout << "\tSetValue: " << setData->iSetValue << std::endl; - ) + DEBUGLOG( + std::cout << "P_CL2FE_GM_REQ_PC_SET_VALUE:" << std::endl; + std::cout << "\tPC_ID: " << setData->iPC_ID << std::endl; + std::cout << "\tSetValueType: " << setData->iSetValueType << std::endl; + std::cout << "\tSetValue: " << setData->iSetValue << std::endl; + ) - response->iPC_ID = setData->iPC_ID; - response->iSetValue = setData->iSetValue; - response->iSetValueType = setData->iSetValueType; + response->iPC_ID = setData->iPC_ID; + response->iSetValue = setData->iSetValue; + response->iSetValueType = setData->iSetValueType; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_GM_REP_PC_SET_VALUE, sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_GM_REP_PC_SET_VALUE, sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE), sock->getFEKey())); } void PlayerManager::heartbeatPlayer(CNSocket* sock, CNPacketData* data) { - players[sock].lastHeartbeat = getTime(); + players[sock].lastHeartbeat = getTime(); } void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { - sP_CL2FE_REQ_PC_EXIT* exitData = (sP_CL2FE_REQ_PC_EXIT*)data->buf; - sP_FE2CL_REP_PC_EXIT_SUCC* response = (sP_FE2CL_REP_PC_EXIT_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_EXIT_SUCC)); + sP_CL2FE_REQ_PC_EXIT* exitData = (sP_CL2FE_REQ_PC_EXIT*)data->buf; + sP_FE2CL_REP_PC_EXIT_SUCC* response = (sP_FE2CL_REP_PC_EXIT_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_EXIT_SUCC)); - response->iID = exitData->iID; - response->iExitCode = 1; + response->iID = exitData->iID; + response->iExitCode = 1; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC), sock->getFEKey())); + sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC), sock->getFEKey())); } void PlayerManager::updatePlayer(CNSocket* key, Player plr) { - PlayerView plrv = players[key]; - plrv.plr = plr; + PlayerView plrv = players[key]; + plrv.plr = plr; - players[key] = plrv; + players[key] = plrv; } \ No newline at end of file From 4dfbc6253ebfaca86175a6a9efa8af6eae23d99c Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sat, 22 Aug 2020 17:18:15 +0200 Subject: [PATCH 05/22] Update PlayerManager.cpp --- src/PlayerManager.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index a074ee5..47dd443 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -214,6 +214,7 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { response->PCLoadData2CL.aNanoBank[i].iStamina = 150; } + // temporarily not add nanos for nano add test through commands //response->PCLoadData2CL.aNanoSlots[0] = 1; //response->PCLoadData2CL.aNanoSlots[1] = 2; //response->PCLoadData2CL.aNanoSlots[2] = 3; From 0ac600e22331f5f456937d55926d1b736e8f5959 Mon Sep 17 00:00:00 2001 From: dongresource Date: Sat, 22 Aug 2020 17:25:42 +0200 Subject: [PATCH 06/22] Extracted all packet ids to a single, definitive enum. It also contains other constant values that might be relevant at some point. --- Makefile | 1 + src/CNLoginServer.hpp | 26 +- src/CNShardServer.hpp | 55 +-- src/Defines.hpp | 840 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 844 insertions(+), 78 deletions(-) create mode 100644 src/Defines.hpp diff --git a/Makefile b/Makefile index d8eef65..7682e12 100644 --- a/Makefile +++ b/Makefile @@ -39,6 +39,7 @@ HDR=\ src/CNShardServer.hpp\ src/CNShared.hpp\ src/CNStructs.hpp\ + src/Defines.hpp\ src/contrib/INIReader.hpp\ src/contrib/JSON.hpp\ src/NanoManager.hpp\ diff --git a/src/CNLoginServer.hpp b/src/CNLoginServer.hpp index 3edddb5..3ff0b97 100644 --- a/src/CNLoginServer.hpp +++ b/src/CNLoginServer.hpp @@ -2,33 +2,11 @@ #define _CNLS_HPP #include "CNProtocol.hpp" +#include "Defines.hpp" #include "Player.hpp" #include -enum LOGINPACKETID { - // client to login server - P_CL2LS_REQ_LOGIN = 301989889, - P_CL2LS_REQ_CHECK_CHAR_NAME = 301989890, - P_CL2LS_REQ_SAVE_CHAR_NAME = 301989891, - P_CL2LS_REQ_CHAR_CREATE = 301989892, - P_CL2LS_REQ_CHAR_SELECT = 301989893, - P_CL2LS_REQ_SHARD_SELECT = 301989895, - P_CL2LS_REP_LIVE_CHECK = 301989900, - P_CL2LS_REQ_SHARD_LIST_INFO = 301989896, - - // login server 2 client - P_LS2CL_REP_LOGIN_SUCC = 553648129, - P_LS2CL_REP_CHAR_INFO = 553648131, - P_LS2CL_REP_CHECK_CHAR_NAME_SUCC = 553648133, - P_LS2CL_REP_SAVE_CHAR_NAME_SUCC = 553648135, - P_LS2CL_REP_CHAR_CREATE_SUCC = 553648137, - P_LS2CL_REP_CHAR_SELECT_SUCC = 553648139, - P_LS2CL_REP_SHARD_SELECT_SUCC = 553648143, - P_LS2CL_REQ_LIVE_CHECK = 553648150, - P_LS2CL_REP_SHARD_LIST_INFO_SUCC = 553648153 -}; - struct CNLoginData { std::map characters; int64_t selectedChar; @@ -46,4 +24,4 @@ public: void killConnection(CNSocket* cns); }; -#endif \ No newline at end of file +#endif diff --git a/src/CNShardServer.hpp b/src/CNShardServer.hpp index 593151f..93c73cc 100644 --- a/src/CNShardServer.hpp +++ b/src/CNShardServer.hpp @@ -2,63 +2,10 @@ #define _CNSS_HPP #include "CNProtocol.hpp" +#include "Defines.hpp" #include -enum SHARDPACKETID { - // client 2 shard - P_CL2FE_REQ_PC_ENTER = 318767105, - P_CL2FE_REQ_PC_LOADING_COMPLETE = 318767245, - P_CL2FE_REP_LIVE_CHECK = 318767221, - P_CL2FE_REQ_NANO_ACTIVE = 318767119, - P_CL2FE_REQ_PC_MOVE = 318767107, - P_CL2FE_REQ_PC_STOP = 318767108, - P_CL2FE_REQ_PC_JUMP = 318767109, - P_CL2FE_REQ_PC_JUMPPAD = 318767165, - P_CL2FE_REQ_PC_LAUNCHER = 318767166, - P_CL2FE_REQ_PC_ZIPLINE = 318767167, - P_CL2FE_REQ_PC_MOVEPLATFORM = 318767168, - P_CL2FE_REQ_PC_SLOPE = 318767169, - P_CL2FE_REQ_PC_GOTO = 318767124, - P_CL2FE_GM_REQ_PC_SET_VALUE = 318767211, - P_CL2FE_REQ_SEND_FREECHAT_MESSAGE = 318767111, - P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT = 318767184, - P_CL2FE_REQ_ITEM_MOVE = 318767114, - P_CL2FE_REQ_PC_ITEM_DELETE = 318767129, - P_CL2FE_REQ_PC_GIVE_ITEM = 318767130, - P_CL2FE_REQ_PC_EXIT = 318767106, - - // shard 2 client - P_FE2CL_REP_NANO_ACTIVE_SUCC = 822083624, - P_FE2CL_REP_PC_ENTER_SUCC = 822083586, - P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC = 822083833, - P_FE2CL_REP_PC_GOTO_SUCC = 822083633, - P_FE2CL_REQ_LIVE_CHECK = 822083792, - P_FE2CL_PC_NEW = 822083587, - P_FE2CL_PC_MOVE = 822083592, - P_FE2CL_PC_STOP = 822083593, - P_FE2CL_PC_JUMP = 822083594, - P_FE2CL_PC_EXIT = 822083590, - P_FE2CL_PC_JUMPPAD = 822083701, - P_FE2CL_PC_LAUNCHER = 822083702, - P_FE2CL_PC_ZIPLINE = 822083703, - P_FE2CL_PC_MOVEPLATFORM = 822083704, - P_FE2CL_PC_SLOPE = 822083705, - P_FE2CL_NPC_ENTER = 822083595, - P_FE2CL_NPC_EXIT = 822083596, - P_FE2CL_ANNOUNCE_MSG = 822083778, - P_FE2CL_GM_REP_PC_SET_VALUE = 822083781, - P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC = 822083602, - P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT = 822083730, - P_FE2CL_PC_ITEM_MOVE_SUCC = 822083610, - P_FE2CL_PC_EQUIP_CHANGE = 822083611, - P_FE2CL_REP_PC_ITEM_DELETE_SUCC = 822083641, - P_FE2CL_REP_PC_GIVE_ITEM_SUCC = 822083681, - P_FE2CL_REP_PC_EXIT_SUCC = 822083589, - P_FE2CL_REP_PC_CHANGE_LEVEL = 822083786, - P_FE2CL_PC_MOTD_LOGIN = 822083793 -}; - #define REGISTER_SHARD_PACKET(pactype, handlr) CNShardServer::ShardPackets[pactype] = handlr; class CNShardServer : public CNServer { diff --git a/src/Defines.hpp b/src/Defines.hpp new file mode 100644 index 0000000..307bce5 --- /dev/null +++ b/src/Defines.hpp @@ -0,0 +1,840 @@ +/* enum definitions from the client */ +#pragma once + +/* + * TODO: It might be a good idea to make this file build-specific, but + * I'm pretty sure there were seldom any new packets added, and they're + * probably always going to be the non-essential things that we won't be + * implementing just yet anyway. + */ + +const float VALUE_BATTERY_EMPTY_PENALTY = 0.5; +const float CN_EP_RANK_1 = 0.8; +const float CN_EP_RANK_2 = 0.7; +const float CN_EP_RANK_3 = 0.5; +const float CN_EP_RANK_4 = 0.3; +const float CN_EP_RANK_5 = 0.29; + +enum { + SUCC = 1, + FAIL = 0, + + SIZEOF_BYTE = 1, + SIZEOF_DWORD = 4, + SIZEOF_INT = 4, + SIZEOF_FLOAT = 4, + SIZEOF_SHORT = 2, + SIZEOF_ULONG = 4, + SIZEOF_UINT64 = 8, + SIZEOF_IP_STRING = 16, + SIZEOF_CN_UID_STRING = 50, + SIZEOF_ACCOUNT_STRING = 33, + SIZEOF_PASSWORD_STRING = 33, + SIZEOF_AUTH_ID_STRING = 255, + + CN_MAX_COUNT_GROUP_MEMBER = 5, + CN_MAX_COUNT_PC_GROUP_MEMBER = 4, + CN_MAX_COUNT_NPC_GROUP_MEMBER = 5, + + CHAT_MAX_STRING = 128, + PC_START_LOCATION_RANDOM_RANGE = 10000, + SIZEOF_ANNOUNCE_STRING = 512, + SERVER_COUNT_SHARD_CLIENT = 25, + + EXIT_CODE_DISCONNECT = 0, + EXIT_CODE_REQ_BY_PC = 1, + EXIT_CODE_REQ_BY_SVR = 2, + EXIT_CODE_REQ_BY_GM = 3, + EXIT_CODE_HACK = 4, + EXIT_CODE_ERROR = 5, + EXIT_CODE_LIVE_CHECK = 6, + EXIT_CODE_REQ_BY_PC_DUPE_LOGIN = 7, + EXIT_CODE_SERVER_ERROR = 99, + + SIZEOF_USER_ID = 32, + SIZEOF_USER_PW = 32, + SIZEOF_PC_SLOT = 4, + SIZEOF_PC_NAME = 16, + SIZEOF_PC_FIRST_NAME = 9, + SIZEOF_PC_LAST_NAME = 17, + SIZEOF_PC_NAME_FLAG = 8, + + GENDER_NONE = 0, + GENDER_MALE = 1, + GENDER_FEMALE = 2, + + MENTOR_CHANGE_BASE_COST = 100, + REPEAT_MISSION_RESET_TIME = 9, + SIZEOF_REPEAT_QUESTFLAG_NUMBER = 8, + FATIGUE_RESET_TIME = 0, + + PC_FATIGUE_KILL_UNIT = 7, + PC_FATIGUE_1_LEVEL = 11420, + PC_FATIGUE_2_LEVEL = 6480, + PC_FATIGUE_MAX_LEVEL = 2, + PC_FUSIONMATTER_MAX = 999999999, + PC_CANDY_MAX = 999999999, + PC_BATTERY_MAX = 9999, + PC_LEVEL_MAX = 36, + SIZEOF_PC_BULLET_SLOT = 3, + PC_TICK_TIME = 5000, + SIZEOF_EQUIP_SLOT = 9, + + EQUIP_SLOT_HAND = 0, + EQUIP_SLOT_UPPERBODY = 1, + EQUIP_SLOT_LOWERBODY = 2, + EQUIP_SLOT_FOOT = 3, + EQUIP_SLOT_HEAD = 4, + EQUIP_SLOT_FACE = 5, + EQUIP_SLOT_BACK = 6, + EQUIP_SLOT_END = 6, + EQUIP_SLOT_HAND_EX = 7, + EQUIP_SLOT_VEHICLE = 8, + + WPN_EQUIP_TYPE_NONE = 0, + WPN_EQUIP_TYPE_OH_BLADE = 1, + WPN_EQUIP_TYPE_OH_CLUB = 2, + WPN_EQUIP_TYPE_OH_PISTOL = 3, + WPN_EQUIP_TYPE_OH_RIPLE = 4, + WPN_EQUIP_TYPE_OH_THROW = 5, + WPN_EQUIP_TYPE_DH_BLADE = 6, + WPN_EQUIP_TYPE_DH_CLUB = 7, + WPN_EQUIP_TYPE_DH_DPISTOL = 8, + WPN_EQUIP_TYPE_DH_RIPLE = 9, + WPN_EQUIP_TYPE_DH_THROW = 10, + WPN_EQUIP_TYPE_DH_ROCKET = 11, + + SIZEOF_INVEN_SLOT = 50, + SIZEOF_QINVEN_SLOT = 50, + SIZEOF_BANK_SLOT = 119, + SIZEOF_RESTORE_SLOT = 5, + SIZEOF_NANO_BANK_SLOT = 37, + SIZEOF_QUEST_SLOT = 1024, + NANO_QUEST_INDEX = 0, + SIZEOF_RQUEST_SLOT = 9, + SIZEOF_QUESTFLAG_NUMBER = 32, + SIZEOF_EP_RECORD_SLOT = 51, + SIZEOF_TRADE_SLOT = 12, + SIZEOF_VENDOR_TABLE_SLOT = 20, + SIZEOF_VENDOR_RESTORE_SLOT = 5, + SIZEOF_QUEST_NPC_SLOT = 3, + SIZEOF_QUEST_ITEM_SLOT = 3, + SIZEOF_MAX_ITEM_STACK = 100, + SIZEOF_PC_SKILL_SLOT = 33, + SIZEOF_QUICK_SLOT = 8, + ENCHANT_WEAPON_MATERIAL_ID = 101, + ENCHANT_DEFENCE_MATERIAL_ID = 102, + SIZEOF_NANO_CARRY_SLOT = 3, + COUNTOF_NANO_PER_SET = 3, + SIZEOF_NANO_SET = 13, + SIZEOF_NANO_STYLE = 3, + NANO_STYLE_NONE = 1, + NANO_STYLE_CRYSTAL = 0, + NANO_STYLE_ENERGY = 1, + NANO_STYLE_FLUID = 2, + SIZEOF_NANO_TYPE = 4, + NANO_TYPE_POWER = 0, + NANO_TYPE_ACCURACY = 1, + NANO_TYPE_PROTECT = 2, + NANO_TYPE_DODGE = 3, + SIZEOF_NANO_TUNE_NEED_ITEM_SLOT = 10, + VALUE_ATTACK_MISS = 1, + + MSG_ONLINE = 1, + MSG_BUSY = 2, + MSG_OFFLINE = 0, + SIZEOF_FREE_CHAT_STRING = 128, + SIZEOF_MENU_CHAT_STRING = 128, + SIZEOF_BUDDYLIST_SLOT = 50, + SIZEOF_EMAIL_SUBJECT_STRING = 32, + SIZEOF_EMAIL_CONTENT_STRING = 512, + SIZEOF_EMAIL_PAGE_SIZE = 5, + SIZEOF_EMAIL_ITEM_CNT = 4, + EMAIL_AND_MONEY_COST = 50, + EMAIL_ITEM_COST = 20, + BUDDYWARP_INTERVAL = 60, + EMAILSEND_TIME_DELAY = 60, + DB_ERROR_INVALID_DATA = 1, + DB_ERROR_HACK_ATTEMPT = 2, + DB_ERROR_ACCESS_FAIL = 3, + DB_ERROR_PC_INSERT_FAIL = 4, + CALL_NPC_MAX_CNT = 2048, + + CN_EP_RING_MAX_CNT = 999, + + HF_BIT_NONE = 0, + HF_BIT_NORMAL = 1, + HF_BIT_CRITICAL = 2, + HF_BIT_STYLE_WIN = 4, + HF_BIT_STYLE_TIE = 8, + HF_BIT_STYLE_LOSE = 16, + SKIN_COLOR_MAX = 12, + HAIR_COLOR_MAX = 18, + EYE_COLOR_MAX = 5, + BODY_TYPE_MAX = 3, + HEIGHT_TYPE_MAX = 5, + CLASS_TYPE_MAX = 4, + CN_EP_RACE_MODE_PRACTICE = 0, + CN_EP_RACE_MODE_RECORD = 1, + CN_EP_SECOM_NPC_TYPE_NUM = 13, + CN_EP_EECOM_NPC_TYPE_NUM = 14, + CN_EP_SIZE_SMALL = 0, + CN_EP_SIZE_MIDDLE = 1, + CN_EP_SIZE_BIG = 2, + CN_EP_TICKET_ITEM_ID_SMALL = 115, + CN_EP_TICKET_ITEM_ID_MIDDLE = 116, + CN_EP_TICKET_ITEM_ID_BIG = 117, + CN_EP_TICKET_ITEM_ID_FREE = 118, + CN_EP_DISTANCE_ERROR_SAFE_RANGE = 1200, + + CN_ACCOUNT_LEVEL__MASTER = 1, + CN_ACCOUNT_LEVEL__POWER_DEVELOPER = 10, + CN_ACCOUNT_LEVEL__QA = 20, + CN_ACCOUNT_LEVEL__GM = 30, + CN_ACCOUNT_LEVEL__CS = 40, + CN_ACCOUNT_LEVEL__FREE_USER = 48, + CN_ACCOUNT_LEVEL__PAY_USER = 49, + CN_ACCOUNT_LEVEL__DEVELOPER = 50, + CN_ACCOUNT_LEVEL__CLOSEBETA_USER = 80, + CN_ACCOUNT_LEVEL__OPENBETA_USER = 85, + CN_ACCOUNT_LEVEL__USER = 99, + + CN_SPECIAL_STATE_FLAG__PRINT_GM = 1, + CN_SPECIAL_STATE_FLAG__INVISIBLE = 2, + CN_SPECIAL_STATE_FLAG__INVULNERABLE = 4, + CN_SPECIAL_STATE_FLAG__FULL_UI = 16, + CN_SPECIAL_STATE_FLAG__COMBAT = 32, + CN_SPECIAL_STATE_FLAG__MUTE_FREECHAT = 64, + + CN_GM_SET_VALUE_TYPE__HP = 1, + CN_GM_SET_VALUE_TYPE__WEAPON_BATTERY = 2, + CN_GM_SET_VALUE_TYPE__NANO_BATTERY = 3, + CN_GM_SET_VALUE_TYPE__FUSION_MATTER = 4, + CN_GM_SET_VALUE_TYPE__CANDY = 5, + CN_GM_SET_VALUE_TYPE__SPEED = 6, + CN_GM_SET_VALUE_TYPE__JUMP = 7, + CN_GM_SET_VALUE_TYPE__END = 8, + + HEIGHT_CLIMBABLE = 150, + CN_GROUP_WARP_CHECK_RANGE = 1000, + WYVERN_LOCATION_FLAG_SIZE = 2, + CN_PC_EVENT_ID_GET_NANO_QUEST = 1, + CN_PC_EVENT_ID_DEFEAT_FUSE_AND_GET_NANO = 2, + _dCN_STREETSTALL__ITEMLIST_COUNT_MAX = 5, + + CSB_BIT_NONE = 0, // 0 + CSB_BIT_UP_MOVE_SPEED = 0x1, // 1 + CSB_BIT_UP_SWIM_SPEED = 0x2, // 2 + CSB_BIT_UP_JUMP_HEIGHT = 0x4, // 4 + CSB_BIT_UP_STEALTH = 0x8, // 8 + CSB_BIT_PHOENIX = 0x10, // 16 + CSB_BIT_PROTECT_BATTERY = 0x20, // 32 + CSB_BIT_PROTECT_INFECTION = 0x40, // 64 + CSB_BIT_DN_MOVE_SPEED = 0x80, // 128 + CSB_BIT_DN_ATTACK_SPEED = 0x100, // 256 + CSB_BIT_STUN = 0x200, // 512 + CSB_BIT_MEZ = 0x400, // 1024 + CSB_BIT_KNOCKDOWN = 0x800, // 2048 + CSB_BIT_MINIMAP_ENEMY = 0x1000, // 4096 + CSB_BIT_MINIMAP_TRESURE = 0x2000, // 8192 + CSB_BIT_REWARD_BLOB = 0x4000, // 16384 + CSB_BIT_REWARD_CASH = 0x8000, // 32768 + CSB_BIT_INFECTION = 0x10000, // 65536 + CSB_BIT_FREEDOM = 0x20000, // 131072 + CSB_BIT_BOUNDINGBALL = 0x40000, // 262144 + CSB_BIT_INVULNERABLE = 0x80000, // 524288 + CSB_BIT_STIMPAKSLOT1 = 0x100000, // 1048576 + CSB_BIT_STIMPAKSLOT2 = 0x200000, // 2097152 + CSB_BIT_STIMPAKSLOT3 = 0x400000, // 4194304 + CSB_BIT_HEAL = 0x800000, // 8388608 + CSB_BIT_EXTRABANK = 0x1000000, // 16777216 + + TIME_BUFF_CONFIRM_KEY_MAX = 2000000000, + READPACKET_SUCC = 0, + READPACKET_FAIL = 1, + READPACKET_RETURN = 2, + BITMASK_FROM2TO = 0x7fffffff, // 2147483647 + BITMASK_FROM = 0x7fffffff, // 2147483647 + BITMASK_TO = 0xf000000, // 251658240 + BITMASK_SENDBLOCK = 0x800000, // 8388608 + BITMASK_AUTHED = 0x400000, // 4194304 + BITMASK_U_ID = 0xfff, // 4095 + + CL2LS = 0x12000000, + CL2FE = 0x13000000, + LS2CL = 0x21000000, + LS2LS = 0x22000000, + LS2DBA = 0x27000000, + FE2CL = 0x31000000, + FE2FE = 0x33000000, + FE2GS = 0x34000000, + FE2EP = 0x36000000, + FE2MSG = 0x38000000, + GS2FE = 0x43000000, + GS2GS = 0x44000000, + GS2AI = 0x45000000, + GS2EP = 0x46000000, + GS2DBA = 0x47000000, + GS2MSG = 0x48000000, + GS2MGR = 0x4a000000, + AI2GS = 0x54000000, + EP2FE = 0x63000000, + EP2GS = 0x64000000, + DBA2GS = 0x74000000, + DBA2EP = 0x75000000, + MSG2FE = 0x7fffffff, + MSG2GS = 0x7fffffff, + MSG2CMSG = 0x7fffffff, + CMSG2MSG = 0x7fffffff, + MGR2SPY = 0x7fffffff, + SPY2MGR = 0x7fffffff, + MGR2SA = 0x7fffffff, + SA2MGR = 0x7fffffff, + SA2SPY = 0x7fffffff, + SPY2SA = 0x7fffffff, + SPY2SVR = 0x7fffffff, + SVR2SPY = 0x7fffffff, + SCH2SVR = 0x7fffffff, + SCH2LS = 0x7fffffff, + SCH2FE = 0x7fffffff, + SCH2GS = 0x7fffffff, + SCH2AI = 0x7fffffff, + SCH2EP = 0x7fffffff, + SCH2DBA = 0x7fffffff, + SCH2MSG = 0x7fffffff, + SCH2CMSG = 0x7fffffff, + CL2CDR = 0x1f000000, + + SENDBLOCK = 0x800000, // 8388608 + AUTHED_X = 0, // 0 + AUTHED_O = 0x400000, // 4194304 + + SEND_SVR_FE = 1, + SEND_SVR_FE_ANY = 2, + SEND_SVR_FE_ALL = 3, + SEND_SVR_AI = 4, + SEND_SVR_AI_ANY = 5, + SEND_SVR_AI_ALL = 6, + SEND_SVR_FE_AI_ALL = 7, + SEND_SVR_DBA = 8, + SEND_SVR_GS = 9, + SEND_SVR_MSG = 10, + SEND_SVR_MSG_ANY = 11, + SEND_SVR_MSG_ALL = 12, + + SEND_UNICAST = 1, + SEND_ANYCAST = 2, + SEND_ANYCAST_NEW = 3, + SEND_BROADCAST = 4, + + CN_PACKET_BUFFER_SIZE = 4096, + + P_CL2LS_REQ_LOGIN = 0x12000001, // 301989889 + P_CL2LS_REQ_CHECK_CHAR_NAME = 0x12000002, // 301989890 + P_CL2LS_REQ_SAVE_CHAR_NAME = 0x12000003, // 301989891 + P_CL2LS_REQ_CHAR_CREATE = 0x12000004, // 301989892 + P_CL2LS_REQ_CHAR_SELECT = 0x12000005, // 301989893 + P_CL2LS_REQ_CHAR_DELETE = 0x12000006, // 301989894 + P_CL2LS_REQ_SHARD_SELECT = 0x12000007, // 301989895 + P_CL2LS_REQ_SHARD_LIST_INFO = 0x12000008, // 301989896 + P_CL2LS_CHECK_NAME_LIST = 0x12000009, // 301989897 + P_CL2LS_REQ_SAVE_CHAR_TUTOR = 0x1200000a, // 301989898 + P_CL2LS_REQ_PC_EXIT_DUPLICATE = 0x1200000b, // 301989899 + P_CL2LS_REP_LIVE_CHECK = 0x1200000c, // 301989900 + P_CL2LS_REQ_CHANGE_CHAR_NAME = 0x1200000d, // 301989901 + P_CL2LS_REQ_SERVER_SELECT = 0x1200000e, // 301989902 + + P_CL2FE_REQ_PC_ENTER = 0x13000001, // 318767105 + P_CL2FE_REQ_PC_EXIT = 0x13000002, // 318767106 + P_CL2FE_REQ_PC_MOVE = 0x13000003, // 318767107 + P_CL2FE_REQ_PC_STOP = 0x13000004, // 318767108 + P_CL2FE_REQ_PC_JUMP = 0x13000005, // 318767109 + P_CL2FE_REQ_PC_ATTACK_NPCs = 0x13000006, // 318767110 + P_CL2FE_REQ_SEND_FREECHAT_MESSAGE = 0x13000007, // 318767111 + P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE = 0x13000008, // 318767112 + P_CL2FE_REQ_PC_REGEN = 0x13000009, // 318767113 + P_CL2FE_REQ_ITEM_MOVE = 0x1300000a, // 318767114 + P_CL2FE_REQ_PC_TASK_START = 0x1300000b, // 318767115 + P_CL2FE_REQ_PC_TASK_END = 0x1300000c, // 318767116 + P_CL2FE_REQ_NANO_EQUIP = 0x1300000d, // 318767117 + P_CL2FE_REQ_NANO_UNEQUIP = 0x1300000e, // 318767118 + P_CL2FE_REQ_NANO_ACTIVE = 0x1300000f, // 318767119 + P_CL2FE_REQ_NANO_TUNE = 0x13000010, // 318767120 + P_CL2FE_REQ_NANO_SKILL_USE = 0x13000011, // 318767121 + P_CL2FE_REQ_PC_TASK_STOP = 0x13000012, // 318767122 + P_CL2FE_REQ_PC_TASK_CONTINUE = 0x13000013, // 318767123 + P_CL2FE_REQ_PC_GOTO = 0x13000014, // 318767124 + P_CL2FE_REQ_CHARGE_NANO_STAMINA = 0x13000015, // 318767125 + P_CL2FE_REQ_PC_KILL_QUEST_NPCs = 0x13000016, // 318767126 + P_CL2FE_REQ_PC_VENDOR_ITEM_BUY = 0x13000017, // 318767127 + P_CL2FE_REQ_PC_VENDOR_ITEM_SELL = 0x13000018, // 318767128 + P_CL2FE_REQ_PC_ITEM_DELETE = 0x13000019, // 318767129 + P_CL2FE_REQ_PC_GIVE_ITEM = 0x1300001a, // 318767130 + P_CL2FE_REQ_PC_ROCKET_STYLE_READY = 0x1300001b, // 318767131 + P_CL2FE_REQ_PC_ROCKET_STYLE_FIRE = 0x1300001c, // 318767132 + P_CL2FE_REQ_PC_ROCKET_STYLE_HIT = 0x1300001d, // 318767133 + P_CL2FE_REQ_PC_GRENADE_STYLE_READY = 0x1300001e, // 318767134 + P_CL2FE_REQ_PC_GRENADE_STYLE_FIRE = 0x1300001f, // 318767135 + P_CL2FE_REQ_PC_GRENADE_STYLE_HIT = 0x13000020, // 318767136 + P_CL2FE_REQ_PC_NANO_CREATE = 0x13000021, // 318767137 + P_CL2FE_REQ_PC_TRADE_OFFER = 0x13000022, // 318767138 + P_CL2FE_REQ_PC_TRADE_OFFER_CANCEL = 0x13000023, // 318767139 + P_CL2FE_REQ_PC_TRADE_OFFER_ACCEPT = 0x13000024, // 318767140 + P_CL2FE_REQ_PC_TRADE_OFFER_REFUSAL = 0x13000025, // 318767141 + P_CL2FE_REQ_PC_TRADE_OFFER_ABORT = 0x13000026, // 318767142 + P_CL2FE_REQ_PC_TRADE_CONFIRM = 0x13000027, // 318767143 + P_CL2FE_REQ_PC_TRADE_CONFIRM_CANCEL = 0x13000028, // 318767144 + P_CL2FE_REQ_PC_TRADE_CONFIRM_ABORT = 0x13000029, // 318767145 + P_CL2FE_REQ_PC_TRADE_ITEM_REGISTER = 0x1300002a, // 318767146 + P_CL2FE_REQ_PC_TRADE_ITEM_UNREGISTER = 0x1300002b, // 318767147 + P_CL2FE_REQ_PC_TRADE_CASH_REGISTER = 0x1300002c, // 318767148 + P_CL2FE_REQ_PC_TRADE_EMOTES_CHAT = 0x1300002d, // 318767149 + P_CL2FE_REQ_PC_BANK_OPEN = 0x1300002e, // 318767150 + P_CL2FE_REQ_PC_BANK_CLOSE = 0x1300002f, // 318767151 + P_CL2FE_REQ_PC_VENDOR_START = 0x13000030, // 318767152 + P_CL2FE_REQ_PC_VENDOR_TABLE_UPDATE = 0x13000031, // 318767153 + P_CL2FE_REQ_PC_VENDOR_ITEM_RESTORE_BUY = 0x13000032, // 318767154 + P_CL2FE_REQ_PC_COMBAT_BEGIN = 0x13000033, // 318767155 + P_CL2FE_REQ_PC_COMBAT_END = 0x13000034, // 318767156 + P_CL2FE_REQ_REQUEST_MAKE_BUDDY = 0x13000035, // 318767157 + P_CL2FE_REQ_ACCEPT_MAKE_BUDDY = 0x13000036, // 318767158 + P_CL2FE_REQ_SEND_BUDDY_FREECHAT_MESSAGE = 0x13000037, // 318767159 + P_CL2FE_REQ_SEND_BUDDY_MENUCHAT_MESSAGE = 0x13000038, // 318767160 + P_CL2FE_REQ_GET_BUDDY_STYLE = 0x13000039, // 318767161 + P_CL2FE_REQ_SET_BUDDY_BLOCK = 0x1300003a, // 318767162 + P_CL2FE_REQ_REMOVE_BUDDY = 0x1300003b, // 318767163 + P_CL2FE_REQ_GET_BUDDY_STATE = 0x1300003c, // 318767164 + P_CL2FE_REQ_PC_JUMPPAD = 0x1300003d, // 318767165 + P_CL2FE_REQ_PC_LAUNCHER = 0x1300003e, // 318767166 + P_CL2FE_REQ_PC_ZIPLINE = 0x1300003f, // 318767167 + P_CL2FE_REQ_PC_MOVEPLATFORM = 0x13000040, // 318767168 + P_CL2FE_REQ_PC_SLOPE = 0x13000041, // 318767169 + P_CL2FE_REQ_PC_STATE_CHANGE = 0x13000042, // 318767170 + P_CL2FE_REQ_PC_MAP_WARP = 0x13000043, // 318767171 + P_CL2FE_REQ_PC_GIVE_NANO = 0x13000044, // 318767172 + P_CL2FE_REQ_NPC_SUMMON = 0x13000045, // 318767173 + P_CL2FE_REQ_NPC_UNSUMMON = 0x13000046, // 318767174 + P_CL2FE_REQ_ITEM_CHEST_OPEN = 0x13000047, // 318767175 + P_CL2FE_REQ_PC_GIVE_NANO_SKILL = 0x13000048, // 318767176 + P_CL2FE_DOT_DAMAGE_ONOFF = 0x13000049, // 318767177 + P_CL2FE_REQ_PC_VENDOR_BATTERY_BUY = 0x1300004a, // 318767178 + P_CL2FE_REQ_PC_WARP_USE_NPC = 0x1300004b, // 318767179 + P_CL2FE_REQ_PC_GROUP_INVITE = 0x1300004c, // 318767180 + P_CL2FE_REQ_PC_GROUP_INVITE_REFUSE = 0x1300004d, // 318767181 + P_CL2FE_REQ_PC_GROUP_JOIN = 0x1300004e, // 318767182 + P_CL2FE_REQ_PC_GROUP_LEAVE = 0x1300004f, // 318767183 + P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT = 0x13000050, // 318767184 + P_CL2FE_REQ_PC_BUDDY_WARP = 0x13000051, // 318767185 + P_CL2FE_REQ_GET_MEMBER_STYLE = 0x13000052, // 318767186 + P_CL2FE_REQ_GET_GROUP_STYLE = 0x13000053, // 318767187 + P_CL2FE_REQ_PC_CHANGE_MENTOR = 0x13000054, // 318767188 + P_CL2FE_REQ_GET_BUDDY_LOCATION = 0x13000055, // 318767189 + P_CL2FE_REQ_NPC_GROUP_SUMMON = 0x13000056, // 318767190 + P_CL2FE_REQ_PC_WARP_TO_PC = 0x13000057, // 318767191 + P_CL2FE_REQ_EP_RANK_GET_LIST = 0x13000058, // 318767192 + P_CL2FE_REQ_EP_RANK_GET_DETAIL = 0x13000059, // 318767193 + P_CL2FE_REQ_EP_RANK_GET_PC_INFO = 0x1300005a, // 318767194 + P_CL2FE_REQ_EP_RACE_START = 0x1300005b, // 318767195 + P_CL2FE_REQ_EP_RACE_END = 0x1300005c, // 318767196 + P_CL2FE_REQ_EP_RACE_CANCEL = 0x1300005d, // 318767197 + P_CL2FE_REQ_EP_GET_RING = 0x1300005e, // 318767198 + P_CL2FE_REQ_IM_CHANGE_SWITCH_STATUS = 0x1300005f, // 318767199 + P_CL2FE_REQ_SHINY_PICKUP = 0x13000060, // 318767200 + P_CL2FE_REQ_SHINY_SUMMON = 0x13000061, // 318767201 + P_CL2FE_REQ_PC_MOVETRANSPORTATION = 0x13000062, // 318767202 + P_CL2FE_REQ_SEND_ALL_GROUP_FREECHAT_MESSAGE = 0x13000063, // 318767203 + P_CL2FE_REQ_SEND_ANY_GROUP_FREECHAT_MESSAGE = 0x13000064, // 318767204 + P_CL2FE_REQ_BARKER = 0x13000065, // 318767205 + P_CL2FE_REQ_SEND_ALL_GROUP_MENUCHAT_MESSAGE = 0x13000066, // 318767206 + P_CL2FE_REQ_SEND_ANY_GROUP_MENUCHAT_MESSAGE = 0x13000067, // 318767207 + P_CL2FE_REQ_REGIST_TRANSPORTATION_LOCATION = 0x13000068, // 318767208 + P_CL2FE_REQ_PC_WARP_USE_TRANSPORTATION = 0x13000069, // 318767209 + P_CL2FE_GM_REQ_PC_SPECIAL_STATE_SWITCH = 0x1300006a, // 318767210 + P_CL2FE_GM_REQ_PC_SET_VALUE = 0x1300006b, // 318767211 + P_CL2FE_GM_REQ_KICK_PLAYER = 0x1300006c, // 318767212 + P_CL2FE_GM_REQ_TARGET_PC_TELEPORT = 0x1300006d, // 318767213 + P_CL2FE_GM_REQ_PC_LOCATION = 0x1300006e, // 318767214 + P_CL2FE_GM_REQ_PC_ANNOUNCE = 0x1300006f, // 318767215 + P_CL2FE_REQ_SET_PC_BLOCK = 0x13000070, // 318767216 + P_CL2FE_REQ_REGIST_RXCOM = 0x13000071, // 318767217 + P_CL2FE_GM_REQ_PC_MOTD_REGISTER = 0x13000072, // 318767218 + P_CL2FE_REQ_ITEM_USE = 0x13000073, // 318767219 + P_CL2FE_REQ_WARP_USE_RECALL = 0x13000074, // 318767220 + P_CL2FE_REP_LIVE_CHECK = 0x13000075, // 318767221 + P_CL2FE_REQ_PC_MISSION_COMPLETE = 0x13000076, // 318767222 + P_CL2FE_REQ_PC_TASK_COMPLETE = 0x13000077, // 318767223 + P_CL2FE_REQ_NPC_INTERACTION = 0x13000078, // 318767224 + P_CL2FE_DOT_HEAL_ONOFF = 0x13000079, // 318767225 + P_CL2FE_REQ_PC_SPECIAL_STATE_SWITCH = 0x1300007a, // 318767226 + P_CL2FE_REQ_PC_EMAIL_UPDATE_CHECK = 0x1300007b, // 318767227 + P_CL2FE_REQ_PC_READ_EMAIL = 0x1300007c, // 318767228 + P_CL2FE_REQ_PC_RECV_EMAIL_PAGE_LIST = 0x1300007d, // 318767229 + P_CL2FE_REQ_PC_DELETE_EMAIL = 0x1300007e, // 318767230 + P_CL2FE_REQ_PC_SEND_EMAIL = 0x1300007f, // 318767231 + P_CL2FE_REQ_PC_RECV_EMAIL_ITEM = 0x13000080, // 318767232 + P_CL2FE_REQ_PC_RECV_EMAIL_CANDY = 0x13000081, // 318767233 + P_CL2FE_GM_REQ_TARGET_PC_SPECIAL_STATE_ONOFF = 0x13000082, // 318767234 + P_CL2FE_REQ_PC_SET_CURRENT_MISSION_ID = 0x13000083, // 318767235 + P_CL2FE_REQ_NPC_GROUP_INVITE = 0x13000084, // 318767236 + P_CL2FE_REQ_NPC_GROUP_KICK = 0x13000085, // 318767237 + P_CL2FE_REQ_PC_FIRST_USE_FLAG_SET = 0x13000086, // 318767238 + P_CL2FE_REQ_PC_TRANSPORT_WARP = 0x13000087, // 318767239 + P_CL2FE_REQ_PC_TIME_TO_GO_WARP = 0x13000088, // 318767240 + P_CL2FE_REQ_PC_RECV_EMAIL_ITEM_ALL = 0x13000089, // 318767241 + P_CL2FE_REQ_CHANNEL_INFO = 0x1300008a, // 318767242 + P_CL2FE_REQ_PC_CHANNEL_NUM = 0x1300008b, // 318767243 + P_CL2FE_REQ_PC_WARP_CHANNEL = 0x1300008c, // 318767244 + P_CL2FE_REQ_PC_LOADING_COMPLETE = 0x1300008d, // 318767245 + P_CL2FE_REQ_PC_FIND_NAME_MAKE_BUDDY = 0x1300008e, // 318767246 + P_CL2FE_REQ_PC_FIND_NAME_ACCEPT_BUDDY = 0x1300008f, // 318767247 + P_CL2FE_REQ_PC_ATTACK_CHARs = 0x13000090, // 318767248 + P_CL2FE_PC_STREETSTALL_REQ_READY = 0x13000091, // 318767249 + P_CL2FE_PC_STREETSTALL_REQ_CANCEL = 0x13000092, // 318767250 + P_CL2FE_PC_STREETSTALL_REQ_REGIST_ITEM = 0x13000093, // 318767251 + P_CL2FE_PC_STREETSTALL_REQ_UNREGIST_ITEM = 0x13000094, // 318767252 + P_CL2FE_PC_STREETSTALL_REQ_SALE_START = 0x13000095, // 318767253 + P_CL2FE_PC_STREETSTALL_REQ_ITEM_LIST = 0x13000096, // 318767254 + P_CL2FE_PC_STREETSTALL_REQ_ITEM_BUY = 0x13000097, // 318767255 + P_CL2FE_REQ_PC_ITEM_COMBINATION = 0x13000098, // 318767256 + P_CL2FE_GM_REQ_SET_PC_SKILL = 0x13000099, // 318767257 + P_CL2FE_REQ_PC_SKILL_ADD = 0x1300009a, // 318767258 + P_CL2FE_REQ_PC_SKILL_DEL = 0x1300009b, // 318767259 + P_CL2FE_REQ_PC_SKILL_USE = 0x1300009c, // 318767260 + P_CL2FE_REQ_PC_ROPE = 0x1300009d, // 318767261 + P_CL2FE_REQ_PC_BELT = 0x1300009e, // 318767262 + P_CL2FE_REQ_PC_VEHICLE_ON = 0x1300009f, // 318767263 + P_CL2FE_REQ_PC_VEHICLE_OFF = 0x130000a0, // 318767264 + P_CL2FE_REQ_PC_REGIST_QUICK_SLOT = 0x130000a1, // 318767265 + P_CL2FE_REQ_PC_DISASSEMBLE_ITEM = 0x130000a2, // 318767266 + P_CL2FE_GM_REQ_REWARD_RATE = 0x130000a3, // 318767267 + P_CL2FE_REQ_PC_ITEM_ENCHANT = 0x130000a4, // 318767268 + + P_FE2CL_ERROR = 0x31000000, // 822083584 + P_FE2CL_REP_PC_ENTER_FAIL = 0x31000001, // 822083585 + P_FE2CL_REP_PC_ENTER_SUCC = 0x31000002, // 822083586 + P_FE2CL_PC_NEW = 0x31000003, // 822083587 + P_FE2CL_REP_PC_EXIT_FAIL = 0x31000004, // 822083588 + P_FE2CL_REP_PC_EXIT_SUCC = 0x31000005, // 822083589 + P_FE2CL_PC_EXIT = 0x31000006, // 822083590 + P_FE2CL_PC_AROUND = 0x31000007, // 822083591 + P_FE2CL_PC_MOVE = 0x31000008, // 822083592 + P_FE2CL_PC_STOP = 0x31000009, // 822083593 + P_FE2CL_PC_JUMP = 0x3100000a, // 822083594 + P_FE2CL_NPC_ENTER = 0x3100000b, // 822083595 + P_FE2CL_NPC_EXIT = 0x3100000c, // 822083596 + P_FE2CL_NPC_MOVE = 0x3100000d, // 822083597 + P_FE2CL_NPC_NEW = 0x3100000e, // 822083598 + P_FE2CL_NPC_AROUND = 0x3100000f, // 822083599 + P_FE2CL_AROUND_DEL_PC = 0x31000010, // 822083600 + P_FE2CL_AROUND_DEL_NPC = 0x31000011, // 822083601 + P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC = 0x31000012, // 822083602 + P_FE2CL_REP_SEND_FREECHAT_MESSAGE_FAIL = 0x31000013, // 822083603 + P_FE2CL_PC_ATTACK_NPCs_SUCC = 0x31000014, // 822083604 + P_FE2CL_PC_ATTACK_NPCs = 0x31000015, // 822083605 + P_FE2CL_NPC_ATTACK_PCs = 0x31000016, // 822083606 + P_FE2CL_REP_PC_REGEN_SUCC = 0x31000017, // 822083607 + P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC = 0x31000018, // 822083608 + P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_FAIL = 0x31000019, // 822083609 + P_FE2CL_PC_ITEM_MOVE_SUCC = 0x3100001a, // 822083610 + P_FE2CL_PC_EQUIP_CHANGE = 0x3100001b, // 822083611 + P_FE2CL_REP_PC_TASK_START_SUCC = 0x3100001c, // 822083612 + P_FE2CL_REP_PC_TASK_START_FAIL = 0x3100001d, // 822083613 + P_FE2CL_REP_PC_TASK_END_SUCC = 0x3100001e, // 822083614 + P_FE2CL_REP_PC_TASK_END_FAIL = 0x3100001f, // 822083615 + P_FE2CL_NPC_SKILL_READY = 0x31000020, // 822083616 + P_FE2CL_NPC_SKILL_FIRE = 0x31000021, // 822083617 + P_FE2CL_NPC_SKILL_HIT = 0x31000022, // 822083618 + P_FE2CL_NPC_SKILL_CORRUPTION_READY = 0x31000023, // 822083619 + P_FE2CL_NPC_SKILL_CORRUPTION_HIT = 0x31000024, // 822083620 + P_FE2CL_NPC_SKILL_CANCEL = 0x31000025, // 822083621 + P_FE2CL_REP_NANO_EQUIP_SUCC = 0x31000026, // 822083622 + P_FE2CL_REP_NANO_UNEQUIP_SUCC = 0x31000027, // 822083623 + P_FE2CL_REP_NANO_ACTIVE_SUCC = 0x31000028, // 822083624 + P_FE2CL_REP_NANO_TUNE_SUCC = 0x31000029, // 822083625 + P_FE2CL_NANO_ACTIVE = 0x3100002a, // 822083626 + P_FE2CL_NANO_SKILL_USE_SUCC = 0x3100002b, // 822083627 + P_FE2CL_NANO_SKILL_USE = 0x3100002c, // 822083628 + P_FE2CL_REP_PC_TASK_STOP_SUCC = 0x3100002d, // 822083629 + P_FE2CL_REP_PC_TASK_STOP_FAIL = 0x3100002e, // 822083630 + P_FE2CL_REP_PC_TASK_CONTINUE_SUCC = 0x3100002f, // 822083631 + P_FE2CL_REP_PC_TASK_CONTINUE_FAIL = 0x31000030, // 822083632 + P_FE2CL_REP_PC_GOTO_SUCC = 0x31000031, // 822083633 + P_FE2CL_REP_CHARGE_NANO_STAMINA = 0x31000032, // 822083634 + P_FE2CL_REP_PC_TICK = 0x31000033, // 822083635 + P_FE2CL_REP_PC_KILL_QUEST_NPCs_SUCC = 0x31000034, // 822083636 + P_FE2CL_REP_PC_VENDOR_ITEM_BUY_SUCC = 0x31000035, // 822083637 + P_FE2CL_REP_PC_VENDOR_ITEM_BUY_FAIL = 0x31000036, // 822083638 + P_FE2CL_REP_PC_VENDOR_ITEM_SELL_SUCC = 0x31000037, // 822083639 + P_FE2CL_REP_PC_VENDOR_ITEM_SELL_FAIL = 0x31000038, // 822083640 + P_FE2CL_REP_PC_ITEM_DELETE_SUCC = 0x31000039, // 822083641 + P_FE2CL_PC_ROCKET_STYLE_READY = 0x3100003a, // 822083642 + P_FE2CL_REP_PC_ROCKET_STYLE_FIRE_SUCC = 0x3100003b, // 822083643 + P_FE2CL_PC_ROCKET_STYLE_FIRE = 0x3100003c, // 822083644 + P_FE2CL_PC_ROCKET_STYLE_HIT = 0x3100003d, // 822083645 + P_FE2CL_PC_GRENADE_STYLE_READY = 0x3100003e, // 822083646 + P_FE2CL_REP_PC_GRENADE_STYLE_FIRE_SUCC = 0x3100003f, // 822083647 + P_FE2CL_PC_GRENADE_STYLE_FIRE = 0x31000040, // 822083648 + P_FE2CL_PC_GRENADE_STYLE_HIT = 0x31000041, // 822083649 + P_FE2CL_REP_PC_TRADE_OFFER = 0x31000042, // 822083650 + P_FE2CL_REP_PC_TRADE_OFFER_CANCEL = 0x31000043, // 822083651 + P_FE2CL_REP_PC_TRADE_OFFER_SUCC = 0x31000044, // 822083652 + P_FE2CL_REP_PC_TRADE_OFFER_REFUSAL = 0x31000045, // 822083653 + P_FE2CL_REP_PC_TRADE_OFFER_ABORT = 0x31000046, // 822083654 + P_FE2CL_REP_PC_TRADE_CONFIRM = 0x31000047, // 822083655 + P_FE2CL_REP_PC_TRADE_CONFIRM_CANCEL = 0x31000048, // 822083656 + P_FE2CL_REP_PC_TRADE_CONFIRM_ABORT = 0x31000049, // 822083657 + P_FE2CL_REP_PC_TRADE_CONFIRM_SUCC = 0x3100004a, // 822083658 + P_FE2CL_REP_PC_TRADE_CONFIRM_FAIL = 0x3100004b, // 822083659 + P_FE2CL_REP_PC_TRADE_ITEM_REGISTER_SUCC = 0x3100004c, // 822083660 + P_FE2CL_REP_PC_TRADE_ITEM_REGISTER_FAIL = 0x3100004d, // 822083661 + P_FE2CL_REP_PC_TRADE_ITEM_UNREGISTER_SUCC = 0x3100004e, // 822083662 + P_FE2CL_REP_PC_TRADE_ITEM_UNREGISTER_FAIL = 0x3100004f, // 822083663 + P_FE2CL_REP_PC_TRADE_CASH_REGISTER_SUCC = 0x31000050, // 822083664 + P_FE2CL_REP_PC_TRADE_CASH_REGISTER_FAIL = 0x31000051, // 822083665 + P_FE2CL_REP_PC_TRADE_EMOTES_CHAT = 0x31000052, // 822083666 + P_FE2CL_REP_PC_NANO_CREATE_SUCC = 0x31000053, // 822083667 + P_FE2CL_REP_PC_NANO_CREATE_FAIL = 0x31000054, // 822083668 + P_FE2CL_REP_NANO_TUNE_FAIL = 0x31000055, // 822083669 + P_FE2CL_REP_PC_BANK_OPEN_SUCC = 0x31000056, // 822083670 + P_FE2CL_REP_PC_BANK_OPEN_FAIL = 0x31000057, // 822083671 + P_FE2CL_REP_PC_BANK_CLOSE_SUCC = 0x31000058, // 822083672 + P_FE2CL_REP_PC_BANK_CLOSE_FAIL = 0x31000059, // 822083673 + P_FE2CL_REP_PC_VENDOR_START_SUCC = 0x3100005a, // 822083674 + P_FE2CL_REP_PC_VENDOR_START_FAIL = 0x3100005b, // 822083675 + P_FE2CL_REP_PC_VENDOR_TABLE_UPDATE_SUCC = 0x3100005c, // 822083676 + P_FE2CL_REP_PC_VENDOR_TABLE_UPDATE_FAIL = 0x3100005d, // 822083677 + P_FE2CL_REP_PC_VENDOR_ITEM_RESTORE_BUY_SUCC = 0x3100005e, // 822083678 + P_FE2CL_REP_PC_VENDOR_ITEM_RESTORE_BUY_FAIL = 0x3100005f, // 822083679 + P_FE2CL_CHAR_TIME_BUFF_TIME_OUT = 0x31000060, // 822083680 + P_FE2CL_REP_PC_GIVE_ITEM_SUCC = 0x31000061, // 822083681 + P_FE2CL_REP_PC_GIVE_ITEM_FAIL = 0x31000062, // 822083682 + P_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC = 0x31000063, // 822083683 + P_FE2CL_REP_PC_BUDDYLIST_INFO_FAIL = 0x31000064, // 822083684 + P_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC = 0x7fffffff, // 2147483647 + P_FE2CL_REP_REQUEST_MAKE_BUDDY_FAIL = 0x31000066, // 822083686 + P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC = 0x31000067, // 822083687 + P_FE2CL_REP_ACCEPT_MAKE_BUDDY_FAIL = 0x31000068, // 822083688 + P_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC = 0x31000069, // 822083689 + P_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_FAIL = 0x3100006a, // 822083690 + P_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC = 0x3100006b, // 822083691 + P_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_FAIL = 0x3100006c, // 822083692 + P_FE2CL_REP_GET_BUDDY_STYLE_SUCC = 0x3100006d, // 822083693 + P_FE2CL_REP_GET_BUDDY_STYLE_FAIL = 0x3100006e, // 822083694 + P_FE2CL_REP_GET_BUDDY_STATE_SUCC = 0x3100006f, // 822083695 + P_FE2CL_REP_GET_BUDDY_STATE_FAIL = 0x31000070, // 822083696 + P_FE2CL_REP_SET_BUDDY_BLOCK_SUCC = 0x31000071, // 822083697 + P_FE2CL_REP_SET_BUDDY_BLOCK_FAIL = 0x31000072, // 822083698 + P_FE2CL_REP_REMOVE_BUDDY_SUCC = 0x31000073, // 822083699 + P_FE2CL_REP_REMOVE_BUDDY_FAIL = 0x31000074, // 822083700 + P_FE2CL_PC_JUMPPAD = 0x31000075, // 822083701 + P_FE2CL_PC_LAUNCHER = 0x31000076, // 822083702 + P_FE2CL_PC_ZIPLINE = 0x31000077, // 822083703 + P_FE2CL_PC_MOVEPLATFORM = 0x31000078, // 822083704 + P_FE2CL_PC_SLOPE = 0x31000079, // 822083705 + P_FE2CL_PC_STATE_CHANGE = 0x3100007a, // 822083706 + P_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC_TO_ACCEPTER = 0x3100007b, // 822083707 + P_FE2CL_REP_REWARD_ITEM = 0x3100007c, // 822083708 + P_FE2CL_REP_ITEM_CHEST_OPEN_SUCC = 0x3100007d, // 822083709 + P_FE2CL_REP_ITEM_CHEST_OPEN_FAIL = 0x3100007e, // 822083710 + P_FE2CL_CHAR_TIME_BUFF_TIME_TICK = 0x3100007f, // 822083711 + P_FE2CL_REP_PC_VENDOR_BATTERY_BUY_SUCC = 0x31000080, // 822083712 + P_FE2CL_REP_PC_VENDOR_BATTERY_BUY_FAIL = 0x31000081, // 822083713 + P_FE2CL_NPC_ROCKET_STYLE_FIRE = 0x31000082, // 822083714 + P_FE2CL_NPC_GRENADE_STYLE_FIRE = 0x31000083, // 822083715 + P_FE2CL_NPC_BULLET_STYLE_HIT = 0x31000084, // 822083716 + P_FE2CL_CHARACTER_ATTACK_CHARACTERs = 0x31000085, // 822083717 + P_FE2CL_PC_GROUP_INVITE = 0x31000086, // 822083718 + P_FE2CL_PC_GROUP_INVITE_FAIL = 0x31000087, // 822083719 + P_FE2CL_PC_GROUP_INVITE_REFUSE = 0x31000088, // 822083720 + P_FE2CL_PC_GROUP_JOIN = 0x31000089, // 822083721 + P_FE2CL_PC_GROUP_JOIN_FAIL = 0x3100008a, // 822083722 + P_FE2CL_PC_GROUP_JOIN_SUCC = 0x3100008b, // 822083723 + P_FE2CL_PC_GROUP_LEAVE = 0x3100008c, // 822083724 + P_FE2CL_PC_GROUP_LEAVE_FAIL = 0x3100008d, // 822083725 + P_FE2CL_PC_GROUP_LEAVE_SUCC = 0x3100008e, // 822083726 + P_FE2CL_PC_GROUP_MEMBER_INFO = 0x3100008f, // 822083727 + P_FE2CL_REP_PC_WARP_USE_NPC_SUCC = 0x31000090, // 822083728 + P_FE2CL_REP_PC_WARP_USE_NPC_FAIL = 0x31000091, // 822083729 + P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT = 0x31000092, // 822083730 + P_FE2CL_REP_PC_CHANGE_MENTOR_SUCC = 0x31000093, // 822083731 + P_FE2CL_REP_PC_CHANGE_MENTOR_FAIL = 0x31000094, // 822083732 + P_FE2CL_REP_GET_MEMBER_STYLE_FAIL = 0x31000095, // 822083733 + P_FE2CL_REP_GET_MEMBER_STYLE_SUCC = 0x31000096, // 822083734 + P_FE2CL_REP_GET_GROUP_STYLE_FAIL = 0x31000097, // 822083735 + P_FE2CL_REP_GET_GROUP_STYLE_SUCC = 0x31000098, // 822083736 + P_FE2CL_PC_REGEN = 0x31000099, // 822083737 + P_FE2CL_INSTANCE_MAP_INFO = 0x3100009a, // 822083738 + P_FE2CL_TRANSPORTATION_ENTER = 0x3100009b, // 822083739 + P_FE2CL_TRANSPORTATION_EXIT = 0x3100009c, // 822083740 + P_FE2CL_TRANSPORTATION_MOVE = 0x3100009d, // 822083741 + P_FE2CL_TRANSPORTATION_NEW = 0x3100009e, // 822083742 + P_FE2CL_TRANSPORTATION_AROUND = 0x3100009f, // 822083743 + P_FE2CL_AROUND_DEL_TRANSPORTATION = 0x310000a0, // 822083744 + P_FE2CL_REP_EP_RANK_LIST = 0x310000a1, // 822083745 + P_FE2CL_REP_EP_RANK_DETAIL = 0x310000a2, // 822083746 + P_FE2CL_REP_EP_RANK_PC_INFO = 0x310000a3, // 822083747 + P_FE2CL_REP_EP_RACE_START_SUCC = 0x310000a4, // 822083748 + P_FE2CL_REP_EP_RACE_START_FAIL = 0x310000a5, // 822083749 + P_FE2CL_REP_EP_RACE_END_SUCC = 0x310000a6, // 822083750 + P_FE2CL_REP_EP_RACE_END_FAIL = 0x310000a7, // 822083751 + P_FE2CL_REP_EP_RACE_CANCEL_SUCC = 0x310000a8, // 822083752 + P_FE2CL_REP_EP_RACE_CANCEL_FAIL = 0x310000a9, // 822083753 + P_FE2CL_REP_EP_GET_RING_SUCC = 0x310000aa, // 822083754 + P_FE2CL_REP_EP_GET_RING_FAIL = 0x310000ab, // 822083755 + P_FE2CL_REP_IM_CHANGE_SWITCH_STATUS = 0x310000ac, // 822083756 + P_FE2CL_SHINY_ENTER = 0x310000ad, // 822083757 + P_FE2CL_SHINY_EXIT = 0x310000ae, // 822083758 + P_FE2CL_SHINY_NEW = 0x310000af, // 822083759 + P_FE2CL_SHINY_AROUND = 0x310000b0, // 822083760 + P_FE2CL_AROUND_DEL_SHINY = 0x310000b1, // 822083761 + P_FE2CL_REP_SHINY_PICKUP_FAIL = 0x310000b2, // 822083762 + P_FE2CL_REP_SHINY_PICKUP_SUCC = 0x310000b3, // 822083763 + P_FE2CL_PC_MOVETRANSPORTATION = 0x310000b4, // 822083764 + P_FE2CL_REP_SEND_ALL_GROUP_FREECHAT_MESSAGE_SUCC = 0x310000b5, // 822083765 + P_FE2CL_REP_SEND_ALL_GROUP_FREECHAT_MESSAGE_FAIL = 0x310000b6, // 822083766 + P_FE2CL_REP_SEND_ANY_GROUP_FREECHAT_MESSAGE_SUCC = 0x310000b7, // 822083767 + P_FE2CL_REP_SEND_ANY_GROUP_FREECHAT_MESSAGE_FAIL = 0x310000b8, // 822083768 + P_FE2CL_REP_BARKER = 0x310000b9, // 822083769 + P_FE2CL_REP_SEND_ALL_GROUP_MENUCHAT_MESSAGE_SUCC = 0x310000ba, // 822083770 + P_FE2CL_REP_SEND_ALL_GROUP_MENUCHAT_MESSAGE_FAIL = 0x310000bb, // 822083771 + P_FE2CL_REP_SEND_ANY_GROUP_MENUCHAT_MESSAGE_SUCC = 0x310000bc, // 822083772 + P_FE2CL_REP_SEND_ANY_GROUP_MENUCHAT_MESSAGE_FAIL = 0x310000bd, // 822083773 + P_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_FAIL = 0x310000be, // 822083774 + P_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_SUCC = 0x310000bf, // 822083775 + P_FE2CL_REP_PC_WARP_USE_TRANSPORTATION_FAIL = 0x310000c0, // 822083776 + P_FE2CL_REP_PC_WARP_USE_TRANSPORTATION_SUCC = 0x310000c1, // 822083777 + P_FE2CL_ANNOUNCE_MSG = 0x310000c2, // 822083778 + P_FE2CL_REP_PC_SPECIAL_STATE_SWITCH_SUCC = 0x310000c3, // 822083779 + P_FE2CL_PC_SPECIAL_STATE_CHANGE = 0x310000c4, // 822083780 + P_FE2CL_GM_REP_PC_SET_VALUE = 0x310000c5, // 822083781 + P_FE2CL_GM_PC_CHANGE_VALUE = 0x310000c6, // 822083782 + P_FE2CL_GM_REP_PC_LOCATION = 0x310000c7, // 822083783 + P_FE2CL_GM_REP_PC_ANNOUNCE = 0x310000c8, // 822083784 + P_FE2CL_REP_PC_BUDDY_WARP_FAIL = 0x310000c9, // 822083785 + P_FE2CL_REP_PC_CHANGE_LEVEL = 0x310000ca, // 822083786 + P_FE2CL_REP_SET_PC_BLOCK_SUCC = 0x310000cb, // 822083787 + P_FE2CL_REP_SET_PC_BLOCK_FAIL = 0x310000cc, // 822083788 + P_FE2CL_REP_REGIST_RXCOM = 0x310000cd, // 822083789 + P_FE2CL_REP_REGIST_RXCOM_FAIL = 0x310000ce, // 822083790 + P_FE2CL_PC_INVEN_FULL_MSG = 0x310000cf, // 822083791 + P_FE2CL_REQ_LIVE_CHECK = 0x310000d0, // 822083792 + P_FE2CL_PC_MOTD_LOGIN = 0x310000d1, // 822083793 + P_FE2CL_REP_PC_ITEM_USE_FAIL = 0x310000d2, // 822083794 + P_FE2CL_REP_PC_ITEM_USE_SUCC = 0x310000d3, // 822083795 + P_FE2CL_PC_ITEM_USE = 0x310000d4, // 822083796 + P_FE2CL_REP_GET_BUDDY_LOCATION_SUCC = 0x310000d5, // 822083797 + P_FE2CL_REP_GET_BUDDY_LOCATION_FAIL = 0x310000d6, // 822083798 + P_FE2CL_REP_PC_RIDING_FAIL = 0x310000d7, // 822083799 + P_FE2CL_REP_PC_RIDING_SUCC = 0x310000d8, // 822083800 + P_FE2CL_PC_RIDING = 0x310000d9, // 822083801 + P_FE2CL_PC_BROOMSTICK_MOVE = 0x310000da, // 822083802 + P_FE2CL_REP_PC_BUDDY_WARP_OTHER_SHARD_SUCC = 0x310000db, // 822083803 + P_FE2CL_REP_WARP_USE_RECALL_FAIL = 0x310000dc, // 822083804 + P_FE2CL_REP_PC_EXIT_DUPLICATE = 0x310000dd, // 822083805 + P_FE2CL_REP_PC_MISSION_COMPLETE_SUCC = 0x310000de, // 822083806 + P_FE2CL_PC_BUFF_UPDATE = 0x310000df, // 822083807 + P_FE2CL_REP_PC_NEW_EMAIL = 0x310000e0, // 822083808 + P_FE2CL_REP_PC_READ_EMAIL_SUCC = 0x310000e1, // 822083809 + P_FE2CL_REP_PC_READ_EMAIL_FAIL = 0x310000e2, // 822083810 + P_FE2CL_REP_PC_RECV_EMAIL_PAGE_LIST_SUCC = 0x310000e3, // 822083811 + P_FE2CL_REP_PC_RECV_EMAIL_PAGE_LIST_FAIL = 0x310000e4, // 822083812 + P_FE2CL_REP_PC_DELETE_EMAIL_SUCC = 0x310000e5, // 822083813 + P_FE2CL_REP_PC_DELETE_EMAIL_FAIL = 0x310000e6, // 822083814 + P_FE2CL_REP_PC_SEND_EMAIL_SUCC = 0x310000e7, // 822083815 + P_FE2CL_REP_PC_SEND_EMAIL_FAIL = 0x310000e8, // 822083816 + P_FE2CL_REP_PC_RECV_EMAIL_ITEM_SUCC = 0x310000e9, // 822083817 + P_FE2CL_REP_PC_RECV_EMAIL_ITEM_FAIL = 0x310000ea, // 822083818 + P_FE2CL_REP_PC_RECV_EMAIL_CANDY_SUCC = 0x310000eb, // 822083819 + P_FE2CL_REP_PC_RECV_EMAIL_CANDY_FAIL = 0x310000ec, // 822083820 + P_FE2CL_PC_SUDDEN_DEAD = 0x310000ed, // 822083821 + P_FE2CL_REP_GM_REQ_TARGET_PC_SPECIAL_STATE_ONOFF_SUCC = 0x310000ee, // 822083822 + P_FE2CL_REP_PC_SET_CURRENT_MISSION_ID = 0x310000ef, // 822083823 + P_FE2CL_REP_NPC_GROUP_INVITE_FAIL = 0x310000f0, // 822083824 + P_FE2CL_REP_NPC_GROUP_INVITE_SUCC = 0x310000f1, // 822083825 + P_FE2CL_REP_NPC_GROUP_KICK_FAIL = 0x310000f2, // 822083826 + P_FE2CL_REP_NPC_GROUP_KICK_SUCC = 0x310000f3, // 822083827 + P_FE2CL_PC_EVENT = 0x310000f4, // 822083828 + P_FE2CL_REP_PC_TRANSPORT_WARP_SUCC = 0x310000f5, // 822083829 + P_FE2CL_REP_PC_TRADE_EMOTES_CHAT_FAIL = 0x310000f6, // 822083830 + P_FE2CL_REP_PC_RECV_EMAIL_ITEM_ALL_SUCC = 0x310000f7, // 822083831 + P_FE2CL_REP_PC_RECV_EMAIL_ITEM_ALL_FAIL = 0x310000f8, // 822083832 + P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC = 0x310000f9, // 822083833 + P_FE2CL_REP_CHANNEL_INFO = 0x310000fa, // 822083834 + P_FE2CL_REP_PC_CHANNEL_NUM = 0x310000fb, // 822083835 + P_FE2CL_REP_PC_WARP_CHANNEL_FAIL = 0x310000fc, // 822083836 + P_FE2CL_REP_PC_WARP_CHANNEL_SUCC = 0x310000fd, // 822083837 + P_FE2CL_REP_PC_FIND_NAME_MAKE_BUDDY_SUCC = 0x310000fe, // 822083838 + P_FE2CL_REP_PC_FIND_NAME_MAKE_BUDDY_FAIL = 0x310000ff, // 822083839 + P_FE2CL_REP_PC_FIND_NAME_ACCEPT_BUDDY_FAIL = 0x31000100, // 822083840 + P_FE2CL_REP_PC_BUDDY_WARP_SAME_SHARD_SUCC = 0x31000101, // 822083841 + P_FE2CL_PC_ATTACK_CHARs_SUCC = 0x31000102, // 822083842 + P_FE2CL_PC_ATTACK_CHARs = 0x31000103, // 822083843 + P_FE2CL_NPC_ATTACK_CHARs = 0x31000104, // 822083844 + P_FE2CL_REP_PC_CHANGE_LEVEL_SUCC = 0x31000105, // 822083845 + P_FE2CL_REP_PC_NANO_CREATE = 0x31000106, // 822083846 + P_FE2CL_PC_STREETSTALL_REP_READY_SUCC = 0x31000107, // 822083847 + P_FE2CL_PC_STREETSTALL_REP_READY_FAIL = 0x31000108, // 822083848 + P_FE2CL_PC_STREETSTALL_REP_CANCEL_SUCC = 0x31000109, // 822083849 + P_FE2CL_PC_STREETSTALL_REP_CANCEL_FAIL = 0x3100010a, // 822083850 + P_FE2CL_PC_STREETSTALL_REP_REGIST_ITEM_SUCC = 0x3100010b, // 822083851 + P_FE2CL_PC_STREETSTALL_REP_REGIST_ITEM_FAIL = 0x3100010c, // 822083852 + P_FE2CL_PC_STREETSTALL_REP_UNREGIST_ITEM_SUCC = 0x3100010d, // 822083853 + P_FE2CL_PC_STREETSTALL_REP_UNREGIST_ITEM_FAIL = 0x3100010e, // 822083854 + P_FE2CL_PC_STREETSTALL_REP_SALE_START_SUCC = 0x3100010f, // 822083855 + P_FE2CL_PC_STREETSTALL_REP_SALE_START_FAIL = 0x31000110, // 822083856 + P_FE2CL_PC_STREETSTALL_REP_ITEM_LIST = 0x31000111, // 822083857 + P_FE2CL_PC_STREETSTALL_REP_ITEM_LIST_FAIL = 0x31000112, // 822083858 + P_FE2CL_PC_STREETSTALL_REP_ITEM_BUY_SUCC_BUYER = 0x31000113, // 822083859 + P_FE2CL_PC_STREETSTALL_REP_ITEM_BUY_SUCC_SELLER = 0x31000114, // 822083860 + P_FE2CL_PC_STREETSTALL_REP_ITEM_BUY_FAIL = 0x31000115, // 822083861 + P_FE2CL_REP_PC_ITEM_COMBINATION_SUCC = 0x31000116, // 822083862 + P_FE2CL_REP_PC_ITEM_COMBINATION_FAIL = 0x31000117, // 822083863 + P_FE2CL_PC_CASH_BUFF_UPDATE = 0x31000118, // 822083864 + P_FE2CL_REP_PC_SKILL_ADD_SUCC = 0x31000119, // 822083865 + P_FE2CL_REP_PC_SKILL_ADD_FAIL = 0x3100011a, // 822083866 + P_FE2CL_REP_PC_SKILL_DEL_SUCC = 0x3100011b, // 822083867 + P_FE2CL_REP_PC_SKILL_DEL_FAIL = 0x3100011c, // 822083868 + P_FE2CL_REP_PC_SKILL_USE_SUCC = 0x3100011d, // 822083869 + P_FE2CL_REP_PC_SKILL_USE_FAIL = 0x3100011e, // 822083870 + P_FE2CL_PC_SKILL_USE = 0x3100011f, // 822083871 + P_FE2CL_PC_ROPE = 0x31000120, // 822083872 + P_FE2CL_PC_BELT = 0x31000121, // 822083873 + P_FE2CL_PC_VEHICLE_ON_SUCC = 0x31000122, // 822083874 + P_FE2CL_PC_VEHICLE_ON_FAIL = 0x31000123, // 822083875 + P_FE2CL_PC_VEHICLE_OFF_SUCC = 0x31000124, // 822083876 + P_FE2CL_PC_VEHICLE_OFF_FAIL = 0x31000125, // 822083877 + P_FE2CL_PC_QUICK_SLOT_INFO = 0x31000126, // 822083878 + P_FE2CL_REP_PC_REGIST_QUICK_SLOT_FAIL = 0x31000127, // 822083879 + P_FE2CL_REP_PC_REGIST_QUICK_SLOT_SUCC = 0x31000128, // 822083880 + P_FE2CL_PC_DELETE_TIME_LIMIT_ITEM = 0x31000129, // 822083881 + P_FE2CL_REP_PC_DISASSEMBLE_ITEM_SUCC = 0x3100012a, // 822083882 + P_FE2CL_REP_PC_DISASSEMBLE_ITEM_FAIL = 0x3100012b, // 822083883 + P_FE2CL_GM_REP_REWARD_RATE_SUCC = 0x3100012c, // 822083884 + P_FE2CL_REP_PC_ITEM_ENCHANT_SUCC = 0x3100012d, // 822083885 + P_FE2CL_REP_PC_ITEM_ENCHANT_FAIL = 0x3100012e, // 822083886 + + P_LS2CL_REP_LOGIN_SUCC = 0x21000001, // 553648129 + P_LS2CL_REP_LOGIN_FAIL = 0x21000002, // 553648130 + P_LS2CL_REP_CHAR_INFO = 0x21000003, // 553648131 + P_LS2CL_REP_CHECK_CHAR_NAME_SUCC = 0x21000005, // 553648133 + P_LS2CL_REP_CHECK_CHAR_NAME_FAIL = 0x21000006, // 553648134 + P_LS2CL_REP_SAVE_CHAR_NAME_SUCC = 0x21000007, // 553648135 + P_LS2CL_REP_SAVE_CHAR_NAME_FAIL = 0x21000008, // 553648136 + P_LS2CL_REP_CHAR_CREATE_SUCC = 0x21000009, // 553648137 + P_LS2CL_REP_CHAR_CREATE_FAIL = 0x2100000a, // 553648138 + P_LS2CL_REP_CHAR_SELECT_SUCC = 0x2100000b, // 553648139 + P_LS2CL_REP_CHAR_SELECT_FAIL = 0x2100000c, // 553648140 + P_LS2CL_REP_CHAR_DELETE_SUCC = 0x2100000d, // 553648141 + P_LS2CL_REP_CHAR_DELETE_FAIL = 0x2100000e, // 553648142 + P_LS2CL_REP_SHARD_SELECT_SUCC = 0x2100000f, // 553648143 + P_LS2CL_REP_SHARD_SELECT_FAIL = 0x21000010, // 553648144 + P_LS2CL_REP_VERSION_CHECK_SUCC = 0x21000011, // 553648145 + P_LS2CL_REP_VERSION_CHECK_FAIL = 0x21000012, // 553648146 + P_LS2CL_REP_CHECK_NAME_LIST_SUCC = 0x21000013, // 553648147 + P_LS2CL_REP_CHECK_NAME_LIST_FAIL = 0x21000014, // 553648148 + P_LS2CL_REP_PC_EXIT_DUPLICATE = 0x21000015, // 553648149 + P_LS2CL_REQ_LIVE_CHECK = 0x21000016, // 553648150 + P_LS2CL_REP_CHANGE_CHAR_NAME_SUCC = 0x21000017, // 553648151 + P_LS2CL_REP_CHANGE_CHAR_NAME_FAIL = 0x21000018, // 553648152 + P_LS2CL_REP_SHARD_LIST_INFO_SUCC = 0x21000019, // 553648153 +}; From 16c525f29d2e09ce24e2ff450408ff0646dc3f55 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sat, 22 Aug 2020 18:46:07 +0200 Subject: [PATCH 07/22] Add DEBUGLOG() --- src/NanoManager.cpp | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index d0028c2..38534d9 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -45,7 +45,10 @@ void NanoManager::nanoGMGiveHandler(CNSocket* sock, CNPacketData* data) { // Add nano to player addNano(sock, nano->iNanoID, 0); - std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " requested to add nano id: " << nano->iNanoID << std::endl; + + DEBUGLOG( + std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " requested to add nano id: " << nano->iNanoID << std::endl; + ) } void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { @@ -60,7 +63,9 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { resp->iActiveNanoSlotNum = nano->iNanoSlotNum; sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC), sock->getFEKey())); - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; + DEBUGLOG( + std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; + ) } void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { @@ -81,8 +86,9 @@ void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { resp->iNanoStamina = 150; // Hardcoded for now sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), sock->getFEKey())); - - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; + DEBUGLOG( + std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; + ) } void NanoManager::nanoSkillSetHandler(CNSocket* sock, CNPacketData* data) { @@ -124,10 +130,12 @@ void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC), sock->getFEKey())); - std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl; + DEBUGLOG( + std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl; + ) - // Update the player - PlayerManager::updatePlayer(sock, plr); + // Update the player + PlayerManager::updatePlayer(sock, plr); } void NanoManager::resetNanoSkill(CNSocket* sock, int16_t nanoId) { From 43f2def80b2c16106d0579142a7e7fba2a6c55e8 Mon Sep 17 00:00:00 2001 From: dongresource Date: Sat, 22 Aug 2020 19:19:46 +0200 Subject: [PATCH 08/22] Report unhandled packets in string form. --- Makefile | 1 + src/CNLoginServer.cpp | 4 +- src/CNShardServer.cpp | 4 +- src/Defines.cpp | 220 ++++++++++++++++++++++++++++++++++++++++++ src/Defines.hpp | 17 ++++ 5 files changed, 242 insertions(+), 4 deletions(-) create mode 100644 src/Defines.cpp diff --git a/Makefile b/Makefile index 7682e12..8566ed9 100644 --- a/Makefile +++ b/Makefile @@ -23,6 +23,7 @@ SRC=\ src/CNShardServer.cpp\ src/CNShared.cpp\ src/CNStructs.cpp\ + src/Defines.cpp\ src/main.cpp\ src/NanoManager.cpp\ src/ItemManager.cpp\ diff --git a/src/CNLoginServer.cpp b/src/CNLoginServer.cpp index 0def10e..e8c96ff 100644 --- a/src/CNLoginServer.cpp +++ b/src/CNLoginServer.cpp @@ -278,11 +278,11 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { break; } default: - std::cerr << "OpenFusion: LOGIN UNIMPLM ERR. PacketType: " << data->type << std::endl; + std::cerr << "OpenFusion: LOGIN UNIMPLM ERR. PacketType: " << Defines::p2str(CL2LS, data->type) << " (" << data->type << ")" << std::endl; break; } } void CNLoginServer::killConnection(CNSocket* cns) { loginSessions.erase(cns); -} \ No newline at end of file +} diff --git a/src/CNShardServer.cpp b/src/CNShardServer.cpp index 7fa9aeb..a043f4a 100644 --- a/src/CNShardServer.cpp +++ b/src/CNShardServer.cpp @@ -20,7 +20,7 @@ void CNShardServer::handlePacket(CNSocket* sock, CNPacketData* data) { if (ShardPackets.find(data->type) != ShardPackets.end()) ShardPackets[data->type](sock, data); else - std::cerr << "OpenFusion: SHARD UNIMPLM ERR. PacketType: " << data->type << std::endl; + std::cerr << "OpenFusion: SHARD UNIMPLM ERR. PacketType: " << Defines::p2str(CL2FE, data->type) << " (" << data->type << ")" << std::endl; } void CNShardServer::killConnection(CNSocket* cns) { @@ -46,4 +46,4 @@ void CNShardServer::onTimer() { sP_FE2CL_REQ_LIVE_CHECK* data = (sP_FE2CL_REQ_LIVE_CHECK*)xmalloc(sizeof(sP_FE2CL_REQ_LIVE_CHECK)); pair.first->sendPacket(new CNPacketData((void*)data, P_FE2CL_REQ_LIVE_CHECK, sizeof(sP_FE2CL_REQ_LIVE_CHECK), pair.first->getFEKey())); } -} \ No newline at end of file +} diff --git a/src/Defines.cpp b/src/Defines.cpp new file mode 100644 index 0000000..e6aac21 --- /dev/null +++ b/src/Defines.cpp @@ -0,0 +1,220 @@ +#include + +#include "Defines.hpp" + +#define STRINGIFY(x) PacketMap(x, #x) + +/* + * Turns out there's not better way to do this... + * We'll only support CL2* packets for now, since we only + * need to print those. + */ +struct PacketMap { + int val; + std::string name; + + PacketMap(int v, std::string n) : val(v), name(n) {}; +}; + +PacketMap cl2ls_map[] = { + STRINGIFY(P_CL2LS_REQ_LOGIN), + STRINGIFY(P_CL2LS_REQ_CHECK_CHAR_NAME), + STRINGIFY(P_CL2LS_REQ_SAVE_CHAR_NAME), + STRINGIFY(P_CL2LS_REQ_CHAR_CREATE), + STRINGIFY(P_CL2LS_REQ_CHAR_SELECT), + STRINGIFY(P_CL2LS_REQ_CHAR_DELETE), + STRINGIFY(P_CL2LS_REQ_SHARD_SELECT), + STRINGIFY(P_CL2LS_REQ_SHARD_LIST_INFO), + STRINGIFY(P_CL2LS_CHECK_NAME_LIST), + STRINGIFY(P_CL2LS_REQ_SAVE_CHAR_TUTOR), + STRINGIFY(P_CL2LS_REQ_PC_EXIT_DUPLICATE), + STRINGIFY(P_CL2LS_REP_LIVE_CHECK), + STRINGIFY(P_CL2LS_REQ_CHANGE_CHAR_NAME), + STRINGIFY(P_CL2LS_REQ_SERVER_SELECT), +}; + +PacketMap cl2fe_map[] = { + STRINGIFY(P_CL2FE_REQ_PC_ENTER), + STRINGIFY(P_CL2FE_REQ_PC_EXIT), + STRINGIFY(P_CL2FE_REQ_PC_MOVE), + STRINGIFY(P_CL2FE_REQ_PC_STOP), + STRINGIFY(P_CL2FE_REQ_PC_JUMP), + STRINGIFY(P_CL2FE_REQ_PC_ATTACK_NPCs), + STRINGIFY(P_CL2FE_REQ_SEND_FREECHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_PC_REGEN), + STRINGIFY(P_CL2FE_REQ_ITEM_MOVE), + STRINGIFY(P_CL2FE_REQ_PC_TASK_START), + STRINGIFY(P_CL2FE_REQ_PC_TASK_END), + STRINGIFY(P_CL2FE_REQ_NANO_EQUIP), + STRINGIFY(P_CL2FE_REQ_NANO_UNEQUIP), + STRINGIFY(P_CL2FE_REQ_NANO_ACTIVE), + STRINGIFY(P_CL2FE_REQ_NANO_TUNE), + STRINGIFY(P_CL2FE_REQ_NANO_SKILL_USE), + STRINGIFY(P_CL2FE_REQ_PC_TASK_STOP), + STRINGIFY(P_CL2FE_REQ_PC_TASK_CONTINUE), + STRINGIFY(P_CL2FE_REQ_PC_GOTO), + STRINGIFY(P_CL2FE_REQ_CHARGE_NANO_STAMINA), + STRINGIFY(P_CL2FE_REQ_PC_KILL_QUEST_NPCs), + STRINGIFY(P_CL2FE_REQ_PC_VENDOR_ITEM_BUY), + STRINGIFY(P_CL2FE_REQ_PC_VENDOR_ITEM_SELL), + STRINGIFY(P_CL2FE_REQ_PC_ITEM_DELETE), + STRINGIFY(P_CL2FE_REQ_PC_GIVE_ITEM), + STRINGIFY(P_CL2FE_REQ_PC_ROCKET_STYLE_READY), + STRINGIFY(P_CL2FE_REQ_PC_ROCKET_STYLE_FIRE), + STRINGIFY(P_CL2FE_REQ_PC_ROCKET_STYLE_HIT), + STRINGIFY(P_CL2FE_REQ_PC_GRENADE_STYLE_READY), + STRINGIFY(P_CL2FE_REQ_PC_GRENADE_STYLE_FIRE), + STRINGIFY(P_CL2FE_REQ_PC_GRENADE_STYLE_HIT), + STRINGIFY(P_CL2FE_REQ_PC_NANO_CREATE), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_OFFER), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_OFFER_CANCEL), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_OFFER_ACCEPT), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_OFFER_REFUSAL), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_OFFER_ABORT), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_CONFIRM), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_CONFIRM_CANCEL), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_CONFIRM_ABORT), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_ITEM_REGISTER), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_ITEM_UNREGISTER), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_CASH_REGISTER), + STRINGIFY(P_CL2FE_REQ_PC_TRADE_EMOTES_CHAT), + STRINGIFY(P_CL2FE_REQ_PC_BANK_OPEN), + STRINGIFY(P_CL2FE_REQ_PC_BANK_CLOSE), + STRINGIFY(P_CL2FE_REQ_PC_VENDOR_START), + STRINGIFY(P_CL2FE_REQ_PC_VENDOR_TABLE_UPDATE), + STRINGIFY(P_CL2FE_REQ_PC_VENDOR_ITEM_RESTORE_BUY), + STRINGIFY(P_CL2FE_REQ_PC_COMBAT_BEGIN), + STRINGIFY(P_CL2FE_REQ_PC_COMBAT_END), + STRINGIFY(P_CL2FE_REQ_REQUEST_MAKE_BUDDY), + STRINGIFY(P_CL2FE_REQ_ACCEPT_MAKE_BUDDY), + STRINGIFY(P_CL2FE_REQ_SEND_BUDDY_FREECHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_SEND_BUDDY_MENUCHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_GET_BUDDY_STYLE), + STRINGIFY(P_CL2FE_REQ_SET_BUDDY_BLOCK), + STRINGIFY(P_CL2FE_REQ_REMOVE_BUDDY), + STRINGIFY(P_CL2FE_REQ_GET_BUDDY_STATE), + STRINGIFY(P_CL2FE_REQ_PC_JUMPPAD), + STRINGIFY(P_CL2FE_REQ_PC_LAUNCHER), + STRINGIFY(P_CL2FE_REQ_PC_ZIPLINE), + STRINGIFY(P_CL2FE_REQ_PC_MOVEPLATFORM), + STRINGIFY(P_CL2FE_REQ_PC_SLOPE), + STRINGIFY(P_CL2FE_REQ_PC_STATE_CHANGE), + STRINGIFY(P_CL2FE_REQ_PC_MAP_WARP), + STRINGIFY(P_CL2FE_REQ_PC_GIVE_NANO), + STRINGIFY(P_CL2FE_REQ_NPC_SUMMON), + STRINGIFY(P_CL2FE_REQ_NPC_UNSUMMON), + STRINGIFY(P_CL2FE_REQ_ITEM_CHEST_OPEN), + STRINGIFY(P_CL2FE_REQ_PC_GIVE_NANO_SKILL), + STRINGIFY(P_CL2FE_DOT_DAMAGE_ONOFF), + STRINGIFY(P_CL2FE_REQ_PC_VENDOR_BATTERY_BUY), + STRINGIFY(P_CL2FE_REQ_PC_WARP_USE_NPC), + STRINGIFY(P_CL2FE_REQ_PC_GROUP_INVITE), + STRINGIFY(P_CL2FE_REQ_PC_GROUP_INVITE_REFUSE), + STRINGIFY(P_CL2FE_REQ_PC_GROUP_JOIN), + STRINGIFY(P_CL2FE_REQ_PC_GROUP_LEAVE), + STRINGIFY(P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT), + STRINGIFY(P_CL2FE_REQ_PC_BUDDY_WARP), + STRINGIFY(P_CL2FE_REQ_GET_MEMBER_STYLE), + STRINGIFY(P_CL2FE_REQ_GET_GROUP_STYLE), + STRINGIFY(P_CL2FE_REQ_PC_CHANGE_MENTOR), + STRINGIFY(P_CL2FE_REQ_GET_BUDDY_LOCATION), + STRINGIFY(P_CL2FE_REQ_NPC_GROUP_SUMMON), + STRINGIFY(P_CL2FE_REQ_PC_WARP_TO_PC), + STRINGIFY(P_CL2FE_REQ_EP_RANK_GET_LIST), + STRINGIFY(P_CL2FE_REQ_EP_RANK_GET_DETAIL), + STRINGIFY(P_CL2FE_REQ_EP_RANK_GET_PC_INFO), + STRINGIFY(P_CL2FE_REQ_EP_RACE_START), + STRINGIFY(P_CL2FE_REQ_EP_RACE_END), + STRINGIFY(P_CL2FE_REQ_EP_RACE_CANCEL), + STRINGIFY(P_CL2FE_REQ_EP_GET_RING), + STRINGIFY(P_CL2FE_REQ_IM_CHANGE_SWITCH_STATUS), + STRINGIFY(P_CL2FE_REQ_SHINY_PICKUP), + STRINGIFY(P_CL2FE_REQ_SHINY_SUMMON), + STRINGIFY(P_CL2FE_REQ_PC_MOVETRANSPORTATION), + STRINGIFY(P_CL2FE_REQ_SEND_ALL_GROUP_FREECHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_SEND_ANY_GROUP_FREECHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_BARKER), + STRINGIFY(P_CL2FE_REQ_SEND_ALL_GROUP_MENUCHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_SEND_ANY_GROUP_MENUCHAT_MESSAGE), + STRINGIFY(P_CL2FE_REQ_REGIST_TRANSPORTATION_LOCATION), + STRINGIFY(P_CL2FE_REQ_PC_WARP_USE_TRANSPORTATION), + STRINGIFY(P_CL2FE_GM_REQ_PC_SPECIAL_STATE_SWITCH), + STRINGIFY(P_CL2FE_GM_REQ_PC_SET_VALUE), + STRINGIFY(P_CL2FE_GM_REQ_KICK_PLAYER), + STRINGIFY(P_CL2FE_GM_REQ_TARGET_PC_TELEPORT), + STRINGIFY(P_CL2FE_GM_REQ_PC_LOCATION), + STRINGIFY(P_CL2FE_GM_REQ_PC_ANNOUNCE), + STRINGIFY(P_CL2FE_REQ_SET_PC_BLOCK), + STRINGIFY(P_CL2FE_REQ_REGIST_RXCOM), + STRINGIFY(P_CL2FE_GM_REQ_PC_MOTD_REGISTER), + STRINGIFY(P_CL2FE_REQ_ITEM_USE), + STRINGIFY(P_CL2FE_REQ_WARP_USE_RECALL), + STRINGIFY(P_CL2FE_REP_LIVE_CHECK), + STRINGIFY(P_CL2FE_REQ_PC_MISSION_COMPLETE), + STRINGIFY(P_CL2FE_REQ_PC_TASK_COMPLETE), + STRINGIFY(P_CL2FE_REQ_NPC_INTERACTION), + STRINGIFY(P_CL2FE_DOT_HEAL_ONOFF), + STRINGIFY(P_CL2FE_REQ_PC_SPECIAL_STATE_SWITCH), + STRINGIFY(P_CL2FE_REQ_PC_EMAIL_UPDATE_CHECK), + STRINGIFY(P_CL2FE_REQ_PC_READ_EMAIL), + STRINGIFY(P_CL2FE_REQ_PC_RECV_EMAIL_PAGE_LIST), + STRINGIFY(P_CL2FE_REQ_PC_DELETE_EMAIL), + STRINGIFY(P_CL2FE_REQ_PC_SEND_EMAIL), + STRINGIFY(P_CL2FE_REQ_PC_RECV_EMAIL_ITEM), + STRINGIFY(P_CL2FE_REQ_PC_RECV_EMAIL_CANDY), + STRINGIFY(P_CL2FE_GM_REQ_TARGET_PC_SPECIAL_STATE_ONOFF), + STRINGIFY(P_CL2FE_REQ_PC_SET_CURRENT_MISSION_ID), + STRINGIFY(P_CL2FE_REQ_NPC_GROUP_INVITE), + STRINGIFY(P_CL2FE_REQ_NPC_GROUP_KICK), + STRINGIFY(P_CL2FE_REQ_PC_FIRST_USE_FLAG_SET), + STRINGIFY(P_CL2FE_REQ_PC_TRANSPORT_WARP), + STRINGIFY(P_CL2FE_REQ_PC_TIME_TO_GO_WARP), + STRINGIFY(P_CL2FE_REQ_PC_RECV_EMAIL_ITEM_ALL), + STRINGIFY(P_CL2FE_REQ_CHANNEL_INFO), + STRINGIFY(P_CL2FE_REQ_PC_CHANNEL_NUM), + STRINGIFY(P_CL2FE_REQ_PC_WARP_CHANNEL), + STRINGIFY(P_CL2FE_REQ_PC_LOADING_COMPLETE), + STRINGIFY(P_CL2FE_REQ_PC_FIND_NAME_MAKE_BUDDY), + STRINGIFY(P_CL2FE_REQ_PC_FIND_NAME_ACCEPT_BUDDY), + STRINGIFY(P_CL2FE_REQ_PC_ATTACK_CHARs), + STRINGIFY(P_CL2FE_PC_STREETSTALL_REQ_READY), + STRINGIFY(P_CL2FE_PC_STREETSTALL_REQ_CANCEL), + STRINGIFY(P_CL2FE_PC_STREETSTALL_REQ_REGIST_ITEM), + STRINGIFY(P_CL2FE_PC_STREETSTALL_REQ_UNREGIST_ITEM), + STRINGIFY(P_CL2FE_PC_STREETSTALL_REQ_SALE_START), + STRINGIFY(P_CL2FE_PC_STREETSTALL_REQ_ITEM_LIST), + STRINGIFY(P_CL2FE_PC_STREETSTALL_REQ_ITEM_BUY), + STRINGIFY(P_CL2FE_REQ_PC_ITEM_COMBINATION), + STRINGIFY(P_CL2FE_GM_REQ_SET_PC_SKILL), + STRINGIFY(P_CL2FE_REQ_PC_SKILL_ADD), + STRINGIFY(P_CL2FE_REQ_PC_SKILL_DEL), + STRINGIFY(P_CL2FE_REQ_PC_SKILL_USE), + STRINGIFY(P_CL2FE_REQ_PC_ROPE), + STRINGIFY(P_CL2FE_REQ_PC_BELT), + STRINGIFY(P_CL2FE_REQ_PC_VEHICLE_ON), + STRINGIFY(P_CL2FE_REQ_PC_VEHICLE_OFF), + STRINGIFY(P_CL2FE_REQ_PC_REGIST_QUICK_SLOT), + STRINGIFY(P_CL2FE_REQ_PC_DISASSEMBLE_ITEM), + STRINGIFY(P_CL2FE_GM_REQ_REWARD_RATE), + STRINGIFY(P_CL2FE_REQ_PC_ITEM_ENCHANT), +}; + +std::string Defines::p2str(int type, int val) { + switch (type) { + case CL2LS: + val = val - CL2LS - 1; + if (val > N_CL2LS) + break; + + return cl2ls_map[val].name; + case CL2FE: + val = val - CL2FE - 1; + if (val > N_CL2FE) + break; + + return cl2fe_map[val].name; + } + + return "UNKNOWN"; +} diff --git a/src/Defines.hpp b/src/Defines.hpp index 307bce5..a10fa75 100644 --- a/src/Defines.hpp +++ b/src/Defines.hpp @@ -838,3 +838,20 @@ enum { P_LS2CL_REP_CHANGE_CHAR_NAME_FAIL = 0x21000018, // 553648152 P_LS2CL_REP_SHARD_LIST_INFO_SUCC = 0x21000019, // 553648153 }; + +/* + * Numbers of packets by type. + * Each is the last packet - the upper bits + 1 + */ +enum { + N_CL2LS = 0xf, + N_CL2FE = 0xa5, + N_FE2CL = 0x12f, + N_LS2CL = 0x1a, + + N_PACKETS = N_CL2LS + N_CL2FE + N_FE2CL + N_LS2CL +}; + +namespace Defines { + std::string p2str(int type, int val); +} From 35c622d8a23944fc4dc98b73847552321a0b42cf Mon Sep 17 00:00:00 2001 From: dongresource Date: Sat, 22 Aug 2020 19:39:13 +0200 Subject: [PATCH 09/22] Add support for verbose logging. --- config.ini | 3 +++ src/CNLoginServer.cpp | 3 +++ src/CNShardServer.cpp | 7 ++++++- src/settings.cpp | 3 +++ src/settings.hpp | 1 + 5 files changed, 16 insertions(+), 1 deletion(-) diff --git a/config.ini b/config.ini index c479216..5586a25 100644 --- a/config.ini +++ b/config.ini @@ -1,3 +1,6 @@ +# should the server print every packet it receives? +verbose=false + # Login Server configuration [login] # must be kept in sync with loginInfo.php diff --git a/src/CNLoginServer.cpp b/src/CNLoginServer.cpp index e8c96ff..1ba5651 100644 --- a/src/CNLoginServer.cpp +++ b/src/CNLoginServer.cpp @@ -17,6 +17,9 @@ CNLoginServer::CNLoginServer(uint16_t p) { } void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { + if (settings::VERBOSE) + std::cout << "OpenFusion: received " << Defines::p2str(CL2LS, data->type) << " (" << data->type << ")" << std::endl; + switch (data->type) { case P_CL2LS_REQ_LOGIN: { if (data->size != sizeof(sP_CL2LS_REQ_LOGIN)) diff --git a/src/CNShardServer.cpp b/src/CNShardServer.cpp index a043f4a..6aa26b4 100644 --- a/src/CNShardServer.cpp +++ b/src/CNShardServer.cpp @@ -3,6 +3,7 @@ #include "CNShardServer.hpp" #include "PlayerManager.hpp" #include "CNShared.hpp" +#include "settings.hpp" #include #include @@ -17,6 +18,10 @@ CNShardServer::CNShardServer(uint16_t p) { } void CNShardServer::handlePacket(CNSocket* sock, CNPacketData* data) { + if (settings::VERBOSE) + std::cout << "OpenFusion: received " << Defines::p2str(CL2FE, data->type) << " (" << data->type << ")" << std::endl; + + if (ShardPackets.find(data->type) != ShardPackets.end()) ShardPackets[data->type](sock, data); else @@ -24,7 +29,7 @@ void CNShardServer::handlePacket(CNSocket* sock, CNPacketData* data) { } void CNShardServer::killConnection(CNSocket* cns) { - // remove from CNSharedData + // remove from CNSharedData Player cachedPlr = PlayerManager::getPlayer(cns); PlayerManager::removePlayer(cns); diff --git a/src/settings.cpp b/src/settings.cpp index 59dff6d..4922f5d 100644 --- a/src/settings.cpp +++ b/src/settings.cpp @@ -3,6 +3,8 @@ #include "contrib/INIReader.hpp" // defaults :) +bool settings::VERBOSE = false; + int settings::LOGINPORT = 8001; bool settings::LOGINRANDCHARACTERS = false; @@ -30,6 +32,7 @@ void settings::init() { return; } + VERBOSE = reader.GetBoolean("", "verbose", VERBOSE); LOGINPORT = reader.GetInteger("login", "port", LOGINPORT); LOGINRANDCHARACTERS = reader.GetBoolean("login", "randomcharacters", LOGINRANDCHARACTERS); SHARDPORT = reader.GetInteger("shard", "port", SHARDPORT); diff --git a/src/settings.hpp b/src/settings.hpp index 7efe1de..6ab94aa 100644 --- a/src/settings.hpp +++ b/src/settings.hpp @@ -2,6 +2,7 @@ #define _SETT_HPP namespace settings { + extern bool VERBOSE; extern int LOGINPORT; extern bool LOGINRANDCHARACTERS; extern int SHARDPORT; From 56bf0db20d6a1d4c7f50b6613e4d45267e19f998 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sat, 22 Aug 2020 20:02:08 +0200 Subject: [PATCH 10/22] Added more nano features (commands, equip & unequip, powers) (#26) * Revert "fixed window build" This reverts commit b94f602537e5773026b25deb868536868530b414. * Revert "Revert "fixed window build"" This reverts commit dac4457ed27267774b1692533d2a9db8c3e344a9. * Add nano power feature * Update CNShardServer.hpp * Update CNShardServer.hpp * Test: Add nano power feature Nano powers are set to the first power in its selection by default. * Update NanoManager.cpp * Test: More nano features * Update NanoManager.hpp * Update PlayerManager.hpp * Update PlayerManager.cpp * Updated indentations * Update PlayerManager.cpp * Add DEBUGLOG() Co-authored-by: CPunch --- src/NanoManager.cpp | 130 +++++++++++++++++++++++++++++++++++++++++- src/NanoManager.hpp | 10 ++++ src/Player.hpp | 1 + src/PlayerManager.cpp | 65 ++++++++++++--------- src/PlayerManager.hpp | 1 + 5 files changed, 178 insertions(+), 29 deletions(-) diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index 4e773d0..38534d9 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -5,6 +5,50 @@ void NanoManager::init() { REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_ACTIVE, nanoSummonHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_EQUIP, nanoEquipHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_UNEQUIP, nanoUnEquipHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GIVE_NANO, nanoGMGiveHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_TUNE, nanoSkillSetHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_NANO_SKILL_USE, nanoSkillUseHandler); +} + +void NanoManager::nanoEquipHandler(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_NANO_EQUIP)) + return; // malformed packet + + sP_CL2FE_REQ_NANO_EQUIP* nano = (sP_CL2FE_REQ_NANO_EQUIP*)data->buf; + sP_FE2CL_REP_NANO_EQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_EQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC)); + resp->iNanoID = nano->iNanoID; + resp->iNanoSlotNum = nano->iNanoSlotNum; + + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_EQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC), sock->getFEKey())); +} + +void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_NANO_UNEQUIP)) + return; // malformed packet + + sP_CL2FE_REQ_NANO_UNEQUIP* nano = (sP_CL2FE_REQ_NANO_UNEQUIP*)data->buf; + sP_FE2CL_REP_NANO_UNEQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_UNEQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC)); + resp->iNanoSlotNum = nano->iNanoSlotNum; + + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_UNEQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC), sock->getFEKey())); +} + +void NanoManager::nanoGMGiveHandler(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_PC_GIVE_NANO)) + return; // ignore the malformed packet + + // Cmd: /nano + sP_CL2FE_REQ_PC_GIVE_NANO* nano = (sP_CL2FE_REQ_PC_GIVE_NANO*)data->buf; + Player plr = PlayerManager::getPlayer(sock); + + // Add nano to player + addNano(sock, nano->iNanoID, 0); + + DEBUGLOG( + std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " requested to add nano id: " << nano->iNanoID << std::endl; + ) } void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { @@ -19,5 +63,89 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { resp->iActiveNanoSlotNum = nano->iNanoSlotNum; sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC), sock->getFEKey())); - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; + DEBUGLOG( + std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; + ) } + +void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_NANO_SKILL_USE)) + return; // malformed packet + + sP_CL2FE_REQ_NANO_SKILL_USE* skill = (sP_CL2FE_REQ_NANO_SKILL_USE*)data->buf; + PlayerView plr = PlayerManager::players[sock]; + + // Send to client + sP_FE2CL_NANO_SKILL_USE_SUCC* resp = (sP_FE2CL_NANO_SKILL_USE_SUCC*)xmalloc(sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC)); + resp->iArg1 = skill->iArg1; + resp->iArg2 = skill->iArg2; + resp->iArg3 = skill->iArg3; + resp->iBulletID = skill->iBulletID; + resp->iTargetCnt = skill->iTargetCnt; + resp->iPC_ID = plr.plr.iID; + resp->iNanoStamina = 150; // Hardcoded for now + + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), sock->getFEKey())); + DEBUGLOG( + std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; + ) +} + +void NanoManager::nanoSkillSetHandler(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_NANO_TUNE)) + return; // malformed packet + + sP_CL2FE_REQ_NANO_TUNE* skill = (sP_CL2FE_REQ_NANO_TUNE*)data->buf; + setNanoSkill(sock, skill->iNanoID, skill->iTuneID); +} + +#pragma region Helper methods +void NanoManager::addNano(CNSocket* sock, int16_t nanoId, int16_t slot) { + Player plr = PlayerManager::getPlayer(sock); + + // Send to client + sP_FE2CL_REP_PC_NANO_CREATE_SUCC* resp = new sP_FE2CL_REP_PC_NANO_CREATE_SUCC(); + resp->Nano.iID = nanoId; + resp->Nano.iStamina = 150; + resp->iQuestItemSlotNum = slot; + + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_NANO_CREATE_SUCC, sizeof(sP_FE2CL_REP_PC_NANO_CREATE_SUCC), sock->getFEKey())); + + // Update player + plr.Nanos[nanoId] = resp->Nano; + PlayerManager::updatePlayer(sock, plr); +} + +void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) { + Player plr = PlayerManager::getPlayer(sock); + sNano nano = plr.Nanos[nanoId]; + + nano.iSkillID = skillId; + plr.Nanos[nanoId] = nano; + + // Send to client + sP_FE2CL_REP_NANO_TUNE_SUCC* resp = (sP_FE2CL_REP_NANO_TUNE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC)); + resp->iNanoID = nanoId; + resp->iSkillID = skillId; + + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC), sock->getFEKey())); + + DEBUGLOG( + std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl; + ) + + // Update the player + PlayerManager::updatePlayer(sock, plr); +} + +void NanoManager::resetNanoSkill(CNSocket* sock, int16_t nanoId) { + Player plr = PlayerManager::getPlayer(sock); + sNano nano = plr.Nanos[nanoId]; + + nano.iSkillID = 0; + plr.Nanos[nanoId] = nano; + + // Update the player + PlayerManager::updatePlayer(sock, plr); +} +#pragma endregion \ No newline at end of file diff --git a/src/NanoManager.hpp b/src/NanoManager.hpp index b583d7a..d1f2646 100644 --- a/src/NanoManager.hpp +++ b/src/NanoManager.hpp @@ -6,6 +6,16 @@ namespace NanoManager { void init(); void nanoSummonHandler(CNSocket* sock, CNPacketData* data); + void nanoEquipHandler(CNSocket* sock, CNPacketData* data); + void nanoUnEquipHandler(CNSocket* sock, CNPacketData* data); + void nanoGMGiveHandler(CNSocket* sock, CNPacketData* data); + void nanoSkillUseHandler(CNSocket* sock, CNPacketData* data); + void nanoSkillSetHandler(CNSocket* sock, CNPacketData* data); + + // Helper methods + void addNano(CNSocket* sock, int16_t nanoId, int16_t slot); + void setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId); + void resetNanoSkill(CNSocket* sock, int16_t nanoId); } #endif \ No newline at end of file diff --git a/src/Player.hpp b/src/Player.hpp index 8c6d917..9c3c001 100644 --- a/src/Player.hpp +++ b/src/Player.hpp @@ -17,6 +17,7 @@ struct Player { int slot; sPCStyle PCStyle; sPCStyle2 PCStyle2; + sNano Nanos[37]; int x, y, z, angle; sItemBase Equip[AEQUIP_COUNT]; diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index ef41df3..47dd443 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -82,7 +82,8 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { if (diffX < settings::VIEWDISTANCE && diffY < settings::VIEWDISTANCE) { yesView.push_back(pair.first); - } else { + } + else { noView.push_back(pair.first); } } @@ -95,7 +96,7 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { sP_FE2CL_PC_EXIT* exitPacket = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); sP_FE2CL_PC_EXIT* exitPacketOther = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); - + exitPacket->iID = players[sock].plr.iID; exitPacketOther->iID = players[otherSock].plr.iID; @@ -164,13 +165,13 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { DEBUGLOG( std::cout << "P_CL2FE_REQ_PC_ENTER:" << std::endl; - std::cout << "\tID: " << U16toU8(enter->szID) << std::endl; - std::cout << "\tSerial: " << enter->iEnterSerialKey << std::endl; - std::cout << "\tTemp: " << enter->iTempValue << std::endl; - std::cout << "\tPC_UID: " << plr.PCStyle.iPC_UID << std::endl; + std::cout << "\tID: " << U16toU8(enter->szID) << std::endl; + std::cout << "\tSerial: " << enter->iEnterSerialKey << std::endl; + std::cout << "\tTemp: " << enter->iTempValue << std::endl; + std::cout << "\tPC_UID: " << plr.PCStyle.iPC_UID << std::endl; ) - response->iID = rand(); + response->iID = rand(); response->uiSvrTime = getTime(); response->PCLoadData2CL.iUserLevel = 1; response->PCLoadData2CL.iHP = 1000 * plr.level; @@ -213,9 +214,10 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { response->PCLoadData2CL.aNanoBank[i].iStamina = 150; } - response->PCLoadData2CL.aNanoSlots[0] = 1; - response->PCLoadData2CL.aNanoSlots[1] = 2; - response->PCLoadData2CL.aNanoSlots[2] = 3; + // temporarily not add nanos for nano add test through commands + //response->PCLoadData2CL.aNanoSlots[0] = 1; + //response->PCLoadData2CL.aNanoSlots[1] = 2; + //response->PCLoadData2CL.aNanoSlots[2] = 3; response->PCLoadData2CL.aQuestFlag[0] = -1; @@ -245,10 +247,10 @@ void PlayerManager::loadPlayer(CNSocket* sock, CNPacketData* data) { DEBUGLOG( std::cout << "P_CL2FE_REQ_PC_LOADING_COMPLETE:" << std::endl; - std::cout << "\tPC_ID: " << complete->iPC_ID << std::endl; + std::cout << "\tPC_ID: " << complete->iPC_ID << std::endl; ) - response->iPC_ID = complete->iPC_ID; + response->iPC_ID = complete->iPC_ID; sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC), sock->getFEKey())); } @@ -256,7 +258,7 @@ void PlayerManager::loadPlayer(CNSocket* sock, CNPacketData* data) { void PlayerManager::movePlayer(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_PC_MOVE)) return; // ignore the malformed packet - + sP_CL2FE_REQ_PC_MOVE* moveData = (sP_CL2FE_REQ_PC_MOVE*)data->buf; updatePlayerPosition(sock, moveData->iX, moveData->iY, moveData->iZ); @@ -276,7 +278,7 @@ void PlayerManager::movePlayer(CNSocket* sock, CNPacketData* data) { moveResponse->fVX = moveData->fVX; moveResponse->fVY = moveData->fVY; moveResponse->fVZ = moveData->fVZ; - + moveResponse->iSpeed = moveData->iSpeed; moveResponse->iCliTime = moveData->iCliTime; // maybe don't send this??? seems unneeded... moveResponse->iSvrTime = tm; @@ -313,7 +315,7 @@ void PlayerManager::stopPlayer(CNSocket* sock, CNPacketData* data) { void PlayerManager::jumpPlayer(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_PC_JUMP)) return; // ignore the malformed packet - + sP_CL2FE_REQ_PC_JUMP* jumpData = (sP_CL2FE_REQ_PC_JUMP*)data->buf; updatePlayerPosition(sock, jumpData->iX, jumpData->iY, jumpData->iZ); @@ -332,7 +334,7 @@ void PlayerManager::jumpPlayer(CNSocket* sock, CNPacketData* data) { jumpResponse->iVX = jumpData->iVX; jumpResponse->iVY = jumpData->iVY; jumpResponse->iVZ = jumpData->iVZ; - + jumpResponse->iSpeed = jumpData->iSpeed; jumpResponse->iCliTime = jumpData->iCliTime; // maybe don't send this??? seems unneeded... jumpResponse->iSvrTime = tm; @@ -344,7 +346,7 @@ void PlayerManager::jumpPlayer(CNSocket* sock, CNPacketData* data) { void PlayerManager::jumppadPlayer(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_PC_JUMPPAD)) return; // ignore the malformed packet - + sP_CL2FE_REQ_PC_JUMPPAD* jumppadData = (sP_CL2FE_REQ_PC_JUMPPAD*)data->buf; updatePlayerPosition(sock, jumppadData->iX, jumppadData->iY, jumppadData->iZ); @@ -362,7 +364,7 @@ void PlayerManager::jumppadPlayer(CNSocket* sock, CNPacketData* data) { jumppadResponse->iVX = jumppadData->iVX; jumppadResponse->iVY = jumppadData->iVY; jumppadResponse->iVZ = jumppadData->iVZ; - + jumppadResponse->iCliTime = jumppadData->iCliTime; jumppadResponse->iSvrTime = tm; @@ -373,7 +375,7 @@ void PlayerManager::jumppadPlayer(CNSocket* sock, CNPacketData* data) { void PlayerManager::launchPlayer(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_PC_LAUNCHER)) return; // ignore the malformed packet - + sP_CL2FE_REQ_PC_LAUNCHER* launchData = (sP_CL2FE_REQ_PC_LAUNCHER*)data->buf; updatePlayerPosition(sock, launchData->iX, launchData->iY, launchData->iZ); @@ -392,7 +394,7 @@ void PlayerManager::launchPlayer(CNSocket* sock, CNPacketData* data) { launchResponse->iVZ = launchData->iVZ; launchResponse->iSpeed = launchData->iSpeed; launchResponse->iAngle = launchData->iAngle; - + launchResponse->iCliTime = launchData->iCliTime; launchResponse->iSvrTime = tm; @@ -513,12 +515,12 @@ void PlayerManager::gotoPlayer(CNSocket* sock, CNPacketData* data) { DEBUGLOG( std::cout << "P_CL2FE_REQ_PC_GOTO:" << std::endl; - std::cout << "\tX: " << gotoData->iToX << std::endl; - std::cout << "\tY: " << gotoData->iToY << std::endl; - std::cout << "\tZ: " << gotoData->iToZ << std::endl; + std::cout << "\tX: " << gotoData->iToX << std::endl; + std::cout << "\tY: " << gotoData->iToY << std::endl; + std::cout << "\tZ: " << gotoData->iToZ << std::endl; ) - response->iX = gotoData->iToX; + response->iX = gotoData->iToX; response->iY = gotoData->iToY; response->iZ = gotoData->iToZ; @@ -534,12 +536,12 @@ void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) { DEBUGLOG( std::cout << "P_CL2FE_GM_REQ_PC_SET_VALUE:" << std::endl; - std::cout << "\tPC_ID: " << setData->iPC_ID << std::endl; - std::cout << "\tSetValueType: " << setData->iSetValueType << std::endl; - std::cout << "\tSetValue: " << setData->iSetValue << std::endl; + std::cout << "\tPC_ID: " << setData->iPC_ID << std::endl; + std::cout << "\tSetValueType: " << setData->iSetValueType << std::endl; + std::cout << "\tSetValue: " << setData->iSetValue << std::endl; ) - response->iPC_ID = setData->iPC_ID; + response->iPC_ID = setData->iPC_ID; response->iSetValue = setData->iSetValue; response->iSetValueType = setData->iSetValueType; @@ -559,3 +561,10 @@ void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC), sock->getFEKey())); } + +void PlayerManager::updatePlayer(CNSocket* key, Player plr) { + PlayerView plrv = players[key]; + plrv.plr = plr; + + players[key] = plrv; +} \ No newline at end of file diff --git a/src/PlayerManager.hpp b/src/PlayerManager.hpp index bfee3f1..3105f51 100644 --- a/src/PlayerManager.hpp +++ b/src/PlayerManager.hpp @@ -25,6 +25,7 @@ namespace PlayerManager { void removePlayer(CNSocket* key); Player getPlayer(CNSocket* key); + void updatePlayer(CNSocket* key, Player plr); void updatePlayerPosition(CNSocket* sock, int X, int Y, int Z); void enterPlayer(CNSocket* sock, CNPacketData* data); From cd9fb6ec25dd285befa6b4df69105c6bb77b22a5 Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 13:08:37 -0500 Subject: [PATCH 11/22] added sanity check to exitGame() --- src/NanoManager.cpp | 1 + src/PlayerManager.cpp | 3 +++ 2 files changed, 4 insertions(+) diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index 38534d9..c692060 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -86,6 +86,7 @@ void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { resp->iNanoStamina = 150; // Hardcoded for now sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), sock->getFEKey())); + DEBUGLOG( std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; ) diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index 47dd443..f956bbc 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -553,6 +553,9 @@ void PlayerManager::heartbeatPlayer(CNSocket* sock, CNPacketData* data) { } void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_PC_EXIT)) + return; + sP_CL2FE_REQ_PC_EXIT* exitData = (sP_CL2FE_REQ_PC_EXIT*)data->buf; sP_FE2CL_REP_PC_EXIT_SUCC* response = (sP_FE2CL_REP_PC_EXIT_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_EXIT_SUCC)); From 4f10ee050507f9295297065a3d46abe70963e6f2 Mon Sep 17 00:00:00 2001 From: Zenpock <70054140+Zenpock@users.noreply.github.com> Date: Sat, 22 Aug 2020 13:11:47 -0500 Subject: [PATCH 12/22] MenuChat Added (#25) * Update CNShardServer.hpp * Update ChatManager.cpp * Update ChatManager.hpp Co-authored-by: CPunch --- src/ChatManager.cpp | 23 ++++++++++++++++++++++- src/ChatManager.hpp | 3 ++- 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/src/ChatManager.cpp b/src/ChatManager.cpp index efbc77f..f786c95 100644 --- a/src/ChatManager.cpp +++ b/src/ChatManager.cpp @@ -6,12 +6,12 @@ void ChatManager::init() { REGISTER_SHARD_PACKET(P_CL2FE_REQ_SEND_FREECHAT_MESSAGE, chatHandler); REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT, emoteHandler); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE, menuChatHandler); } void ChatManager::chatHandler(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_SEND_FREECHAT_MESSAGE)) return; // malformed packet - sP_CL2FE_REQ_SEND_FREECHAT_MESSAGE* chat = (sP_CL2FE_REQ_SEND_FREECHAT_MESSAGE*)data->buf; PlayerView plr = PlayerManager::players[sock]; @@ -31,7 +31,28 @@ void ChatManager::chatHandler(CNSocket* sock, CNPacketData* data) { otherSock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC), otherSock->getFEKey())); } } +void ChatManager::menuChatHandler(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE)) + return; // malformed packet + sP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE* chat = (sP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE*)data->buf; + PlayerView plr = PlayerManager::players[sock]; + // send to client + sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC* resp = (sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC)); + memcpy(resp->szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); + resp->iPC_ID = PlayerManager::players[sock].plr.iID; + resp->iEmoteCode = chat->iEmoteCode; + sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC), sock->getFEKey())); + + // send to visible players + for (CNSocket* otherSock : plr.viewable) { + sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC* resp = (sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC)); + memcpy(resp->szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); + resp->iPC_ID = PlayerManager::players[sock].plr.iID; + resp->iEmoteCode = chat->iEmoteCode; + otherSock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC), otherSock->getFEKey())); + } +} void ChatManager::emoteHandler(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT)) return; // ignore the malformed packet diff --git a/src/ChatManager.hpp b/src/ChatManager.hpp index 3f669d7..241d47b 100644 --- a/src/ChatManager.hpp +++ b/src/ChatManager.hpp @@ -8,6 +8,7 @@ namespace ChatManager { void chatHandler(CNSocket* sock, CNPacketData* data); void emoteHandler(CNSocket* sock, CNPacketData* data); + void menuChatHandler(CNSocket* sock, CNPacketData* data); } -#endif \ No newline at end of file +#endif From 2072bdcff7800677176cb9c2e08e5810cd39973e Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 13:29:38 -0500 Subject: [PATCH 13/22] updated appveyor --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a242792..b897783 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ ![](res/radiorave_logo.png) -[![AppVeyor](https://ci.appveyor.com/api/projects/status/github/OpenFusionProject/OpenFusion?svg=true)](https://ci.appveyor.com/project/Raymonf/openfusion) +[![AppVeyor](https://ci.appveyor.com/api/projects/status/github/OpenFusionProject/OpenFusion?svg=true)](https://ci.appveyor.com/project/OpenFusionProject/openfusion) [![Discord](https://img.shields.io/badge/chat-on%20discord-7289da.svg?logo=discord)](https://discord.gg/DYavckB) OpenFusion is a landwalker server for FusionFall. It currently supports versions `beta-20100104` and `beta-20100728` of the original game. From 35b424c5318d83d8de79c64559ebc7ce7a808aee Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 13:38:27 -0500 Subject: [PATCH 14/22] fixed warnings for VC++ --- src/CNProtocol.hpp | 2 +- src/CNShardServer.cpp | 2 +- src/CNStructs.cpp | 2 +- src/CNStructs.hpp | 2 +- src/Defines.hpp | 12 ++++++------ src/PlayerManager.hpp | 2 +- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/CNProtocol.hpp b/src/CNProtocol.hpp index 5887384..8f87962 100644 --- a/src/CNProtocol.hpp +++ b/src/CNProtocol.hpp @@ -133,7 +133,7 @@ protected: void init(); bool active = true; - long int lastTimer; + uint64_t lastTimer; public: PacketHandler pHandler; diff --git a/src/CNShardServer.cpp b/src/CNShardServer.cpp index 6aa26b4..e603d01 100644 --- a/src/CNShardServer.cpp +++ b/src/CNShardServer.cpp @@ -37,7 +37,7 @@ void CNShardServer::killConnection(CNSocket* cns) { } void CNShardServer::onTimer() { - long int currTime = getTime(); + uint64_t currTime = getTime(); auto cachedPlayers = PlayerManager::players; diff --git a/src/CNStructs.cpp b/src/CNStructs.cpp index b580cc3..c58c6fe 100644 --- a/src/CNStructs.cpp +++ b/src/CNStructs.cpp @@ -10,7 +10,7 @@ std::string U16toU8(char16_t* src) { } // returns number of char16_t that was written at des -int U8toU16(std::string src, char16_t* des) { +size_t U8toU16(std::string src, char16_t* des) { std::wstring_convert,char16_t> convert; std::u16string tmp = convert.from_bytes(src); diff --git a/src/CNStructs.hpp b/src/CNStructs.hpp index 113d794..6adebec 100644 --- a/src/CNStructs.hpp +++ b/src/CNStructs.hpp @@ -28,7 +28,7 @@ // TODO: rewrite U16toU8 & U8toU16 to not use codecvt std::string U16toU8(char16_t* src); -int U8toU16(std::string src, char16_t* des); // returns number of char16_t that was written at des +size_t U8toU16(std::string src, char16_t* des); // returns number of char16_t that was written at des uint64_t getTime(); // The PROTOCOL_VERSION definition is defined by the build system. diff --git a/src/Defines.hpp b/src/Defines.hpp index a10fa75..21eb8f2 100644 --- a/src/Defines.hpp +++ b/src/Defines.hpp @@ -8,12 +8,12 @@ * implementing just yet anyway. */ -const float VALUE_BATTERY_EMPTY_PENALTY = 0.5; -const float CN_EP_RANK_1 = 0.8; -const float CN_EP_RANK_2 = 0.7; -const float CN_EP_RANK_3 = 0.5; -const float CN_EP_RANK_4 = 0.3; -const float CN_EP_RANK_5 = 0.29; +const float VALUE_BATTERY_EMPTY_PENALTY = 0.5f; +const float CN_EP_RANK_1 = 0.8f; +const float CN_EP_RANK_2 = 0.7f; +const float CN_EP_RANK_3 = 0.5f; +const float CN_EP_RANK_4 = 0.3f; +const float CN_EP_RANK_5 = 0.29f; enum { SUCC = 1, diff --git a/src/PlayerManager.hpp b/src/PlayerManager.hpp index 3105f51..34cfb6a 100644 --- a/src/PlayerManager.hpp +++ b/src/PlayerManager.hpp @@ -13,7 +13,7 @@ struct PlayerView { std::list viewable; std::list viewableNPCs; Player plr; - int long lastHeartbeat; + uint64_t lastHeartbeat; }; From 0ff1f74cd381ee58c5c0f65fd3389ef525e21f62 Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 14:02:58 -0500 Subject: [PATCH 15/22] fixed inet_ntoa warnings --- src/CNProtocol.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/CNProtocol.cpp b/src/CNProtocol.cpp index f7df999..ce76875 100644 --- a/src/CNProtocol.cpp +++ b/src/CNProtocol.cpp @@ -1,6 +1,10 @@ #include "CNProtocol.hpp" #include "CNStructs.hpp" +#ifdef _MSC_VER + #define _WINSOCK_DEPRECATED_NO_WARNINGS +#endif + // ========================================================[[ CNSocketEncryption ]]======================================================== // literally C/P from the client and converted to C++ (does some byte swapping /shrug) From 94b0dc724e2ebb087a596167ac1579d6ca1e6bf3 Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 18:31:09 -0500 Subject: [PATCH 16/22] major refactoring --- src/CNLoginServer.cpp | 156 +++++++------- src/CNLoginServer.hpp | 1 + src/CNProtocol.cpp | 74 ++++--- src/CNProtocol.hpp | 18 +- src/CNShardServer.cpp | 8 +- src/CNShardServer.hpp | 1 + src/ChatManager.cpp | 46 ++-- src/ItemManager.cpp | 68 +++--- src/NPCManager.cpp | 16 +- src/NanoManager.cpp | 60 +++--- src/PlayerManager.cpp | 475 ++++++++++++++++++++---------------------- 11 files changed, 466 insertions(+), 457 deletions(-) diff --git a/src/CNLoginServer.cpp b/src/CNLoginServer.cpp index 1ba5651..f175e30 100644 --- a/src/CNLoginServer.cpp +++ b/src/CNLoginServer.cpp @@ -26,8 +26,8 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2LS_REQ_LOGIN* login = (sP_CL2LS_REQ_LOGIN*)data->buf; - sP_LS2CL_REP_LOGIN_SUCC* response = (sP_LS2CL_REP_LOGIN_SUCC*)xmalloc(sizeof(sP_LS2CL_REP_LOGIN_SUCC)); - uint64_t cachedKey = sock->getEKey(); // so we can still send the response packet with the correct key + sP_LS2CL_REP_LOGIN_SUCC resp; + uint64_t cachedKey = sock->getEKey(); // so we can still send the resp packet with the correct key int charCount = 2; // send 4 randomly generated characters for now DEBUGLOG( @@ -37,71 +37,71 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { std::cout << "\tID: " << U16toU8(login->szID) << " Password: " << U16toU8(login->szPassword) << std::endl; ) - response->iCharCount = charCount; - response->iSlotNum = 1; - response->iPaymentFlag = 1; - response->iOpenBetaFlag = 0; - response->uiSvrTime = getTime(); + resp.iCharCount = charCount; + resp.iSlotNum = 1; + resp.iPaymentFlag = 1; + resp.iOpenBetaFlag = 0; + resp.uiSvrTime = getTime(); - // set username in response packet - memcpy(response->szID, login->szID, sizeof(char16_t) * 33); + // set username in resp packet + memcpy(resp.szID, login->szID, sizeof(char16_t) * 33); + + // send the resp in with original key + sock->sendPacket((void*)&resp, P_LS2CL_REP_LOGIN_SUCC, sizeof(sP_LS2CL_REP_LOGIN_SUCC)); // update keys - sock->setEKey(CNSocketEncryption::createNewKey(response->uiSvrTime, response->iCharCount + 1, response->iSlotNum + 1)); + sock->setEKey(CNSocketEncryption::createNewKey(resp.uiSvrTime, resp.iCharCount + 1, resp.iSlotNum + 1)); sock->setFEKey(CNSocketEncryption::createNewKey((uint64_t)(*(uint64_t*)&CNSocketEncryption::defaultKey[0]), login->iClientVerC, 1)); - // send the response in with original key - sock->sendPacket(new CNPacketData((void*)response, P_LS2CL_REP_LOGIN_SUCC, sizeof(sP_LS2CL_REP_LOGIN_SUCC), cachedKey)); - loginSessions[sock] = CNLoginData(); if (settings::LOGINRANDCHARACTERS) { // now send the characters :) for (int i = 0; i < charCount; i++) { - sP_LS2CL_REP_CHAR_INFO* charInfo = (sP_LS2CL_REP_CHAR_INFO*)xmalloc(sizeof(sP_LS2CL_REP_CHAR_INFO)); - charInfo->iSlot = (int8_t)i + 1; - charInfo->iLevel = (int16_t)1; - charInfo->sPC_Style.iPC_UID = rand(); // unique identifier for the character - charInfo->sPC_Style.iNameCheck = 1; - charInfo->sPC_Style.iGender = (i%2)+1; // can be 1(boy) or 2(girl) - charInfo->sPC_Style.iFaceStyle = 1; - charInfo->sPC_Style.iHairStyle = 1; - charInfo->sPC_Style.iHairColor = (rand()%19) + 1; // 1 - 19 - charInfo->sPC_Style.iSkinColor = (rand()%13) + 1; // 1 - 13 - charInfo->sPC_Style.iEyeColor = (rand()%6) + 1; // 1 - 6 - charInfo->sPC_Style.iHeight = (rand()%6); // 0 -5 - charInfo->sPC_Style.iBody = (rand()%4); // 0 - 3 - charInfo->sPC_Style.iClass = 0; - charInfo->sPC_Style2.iAppearanceFlag = 1; - charInfo->sPC_Style2.iPayzoneFlag = 1; - charInfo->sPC_Style2.iTutorialFlag = 1; + sP_LS2CL_REP_CHAR_INFO charInfo = sP_LS2CL_REP_CHAR_INFO(); + charInfo.iSlot = (int8_t)i + 1; + charInfo.iLevel = (int16_t)1; + charInfo.sPC_Style.iPC_UID = rand(); // unique identifier for the character + charInfo.sPC_Style.iNameCheck = 1; + charInfo.sPC_Style.iGender = (i%2)+1; // can be 1(boy) or 2(girl) + charInfo.sPC_Style.iFaceStyle = 1; + charInfo.sPC_Style.iHairStyle = 1; + charInfo.sPC_Style.iHairColor = (rand()%19) + 1; // 1 - 19 + charInfo.sPC_Style.iSkinColor = (rand()%13) + 1; // 1 - 13 + charInfo.sPC_Style.iEyeColor = (rand()%6) + 1; // 1 - 6 + charInfo.sPC_Style.iHeight = (rand()%6); // 0 -5 + charInfo.sPC_Style.iBody = (rand()%4); // 0 - 3 + charInfo.sPC_Style.iClass = 0; + charInfo.sPC_Style2.iAppearanceFlag = 1; + charInfo.sPC_Style2.iPayzoneFlag = 1; + charInfo.sPC_Style2.iTutorialFlag = 1; // past's town hall - charInfo->iX = settings::SPAWN_X; - charInfo->iY = settings::SPAWN_Y; - charInfo->iZ = settings::SPAWN_Z; + charInfo.iX = settings::SPAWN_X; + charInfo.iY = settings::SPAWN_Y; + charInfo.iZ = settings::SPAWN_Z; - U8toU16(std::string("Player"), charInfo->sPC_Style.szFirstName); - U8toU16(std::to_string(i + 1), charInfo->sPC_Style.szLastName); + U8toU16(std::string("Player"), charInfo.sPC_Style.szFirstName); + U8toU16(std::to_string(i + 1), charInfo.sPC_Style.szLastName); - int64_t UID = charInfo->sPC_Style.iPC_UID; + int64_t UID = charInfo.sPC_Style.iPC_UID; loginSessions[sock].characters[UID] = Player(); - loginSessions[sock].characters[UID].level = charInfo->iLevel; - loginSessions[sock].characters[UID].slot = charInfo->iSlot; + loginSessions[sock].characters[UID].level = charInfo.iLevel; + loginSessions[sock].characters[UID].slot = charInfo.iSlot; loginSessions[sock].characters[UID].FEKey = sock->getFEKey(); - loginSessions[sock].characters[UID].x = charInfo->iX; - loginSessions[sock].characters[UID].y = charInfo->iY; - loginSessions[sock].characters[UID].z = charInfo->iZ; - loginSessions[sock].characters[UID].PCStyle = charInfo->sPC_Style; - loginSessions[sock].characters[UID].PCStyle2 = charInfo->sPC_Style2; + loginSessions[sock].characters[UID].x = charInfo.iX; + loginSessions[sock].characters[UID].y = charInfo.iY; + loginSessions[sock].characters[UID].z = charInfo.iZ; + loginSessions[sock].characters[UID].PCStyle = charInfo.sPC_Style; + loginSessions[sock].characters[UID].PCStyle2 = charInfo.sPC_Style2; loginSessions[sock].characters[UID].IsGM = false; for (int i = 0; i < AEQUIP_COUNT; i++) { // setup equips - charInfo->aEquip[i].iID = 0; - charInfo->aEquip[i].iType = i; - charInfo->aEquip[i].iOpt = 0; - loginSessions[sock].characters[UID].Equip[i] = charInfo->aEquip[i]; + charInfo.aEquip[i].iID = 0; + charInfo.aEquip[i].iType = i; + charInfo.aEquip[i].iOpt = 0; + loginSessions[sock].characters[UID].Equip[i] = charInfo.aEquip[i]; } for (int i = 0; i < AINVEN_COUNT; i++) { @@ -115,7 +115,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { if (i == 0) loginSessions[sock].selectedChar = UID; - sock->sendPacket(new CNPacketData((void*)charInfo, P_LS2CL_REP_CHAR_INFO, sizeof(sP_LS2CL_REP_CHAR_INFO), sock->getEKey())); + sock->sendPacket((void*)&charInfo, P_LS2CL_REP_CHAR_INFO, sizeof(sP_LS2CL_REP_CHAR_INFO)); } } @@ -131,18 +131,18 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { // naughty words allowed!!!!!!!! (also for some reason, the client will always show 'Player 0' if you manually type a name. It will show up for other connected players though) sP_CL2LS_REQ_CHECK_CHAR_NAME* nameCheck = (sP_CL2LS_REQ_CHECK_CHAR_NAME*)data->buf; - sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC* response = (sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC*)xmalloc(sizeof(sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC)); + sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC resp; DEBUGLOG( std::cout << "P_CL2LS_REQ_CHECK_CHAR_NAME:" << std::endl; std::cout << "\tFirstName: " << U16toU8(nameCheck->szFirstName) << " LastName: " << U16toU8(nameCheck->szLastName) << std::endl; ) - memcpy(response->szFirstName, nameCheck->szFirstName, sizeof(char16_t) * 9); - memcpy(response->szLastName, nameCheck->szLastName, sizeof(char16_t) * 17); + memcpy(resp.szFirstName, nameCheck->szFirstName, sizeof(char16_t) * 9); + memcpy(resp.szLastName, nameCheck->szLastName, sizeof(char16_t) * 17); // fr*ck allowed!!! - sock->sendPacket(new CNPacketData((void*)response, P_LS2CL_REP_CHECK_CHAR_NAME_SUCC, sizeof(sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC), sock->getEKey())); + sock->sendPacket((void*)&resp, P_LS2CL_REP_CHECK_CHAR_NAME_SUCC, sizeof(sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC)); break; } case P_CL2LS_REQ_SAVE_CHAR_NAME: { @@ -150,7 +150,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { return; sP_CL2LS_REQ_SAVE_CHAR_NAME* save = (sP_CL2LS_REQ_SAVE_CHAR_NAME*)data->buf; - sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC* response = (sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC*)xmalloc(sizeof(sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC)); + sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC resp; DEBUGLOG( std::cout << "P_CL2LS_REQ_SAVE_CHAR_NAME:" << std::endl; @@ -159,12 +159,12 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { std::cout << "\tName: " << U16toU8(save->szFirstName) << " " << U16toU8(save->szLastName) << std::endl; ) - response->iSlotNum = save->iSlotNum; - response->iGender = save->iGender; - memcpy(response->szFirstName, save->szFirstName, sizeof(char16_t) * 9); - memcpy(response->szLastName, save->szLastName, sizeof(char16_t) * 17); + resp.iSlotNum = save->iSlotNum; + resp.iGender = save->iGender; + memcpy(resp.szFirstName, save->szFirstName, sizeof(char16_t) * 9); + memcpy(resp.szLastName, save->szLastName, sizeof(char16_t) * 17); - sock->sendPacket(new CNPacketData((void*)response, P_LS2CL_REP_SAVE_CHAR_NAME_SUCC, sizeof(sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC), sock->getEKey())); + sock->sendPacket((void*)&resp, P_LS2CL_REP_SAVE_CHAR_NAME_SUCC, sizeof(sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC)); break; } case P_CL2LS_REQ_CHAR_CREATE: { @@ -172,7 +172,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { return; sP_CL2LS_REQ_CHAR_CREATE* character = (sP_CL2LS_REQ_CHAR_CREATE*)data->buf; - sP_LS2CL_REP_CHAR_CREATE_SUCC* response = (sP_LS2CL_REP_CHAR_CREATE_SUCC*)xmalloc(sizeof(sP_LS2CL_REP_CHAR_CREATE_SUCC)); + sP_LS2CL_REP_CHAR_CREATE_SUCC resp; DEBUGLOG( std::cout << "P_CL2LS_REQ_CHAR_CREATE:" << std::endl; @@ -206,12 +206,12 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { //} character->PCStyle.iNameCheck = 1; - response->sPC_Style = character->PCStyle; - response->sPC_Style2.iAppearanceFlag = 1; - response->sPC_Style2.iTutorialFlag = 1; - response->sPC_Style2.iPayzoneFlag = 1; - response->iLevel = 1; - response->sOn_Item = character->sOn_Item; + resp.sPC_Style = character->PCStyle; + resp.sPC_Style2.iAppearanceFlag = 1; + resp.sPC_Style2.iTutorialFlag = 1; + resp.sPC_Style2.iPayzoneFlag = 1; + resp.iLevel = 1; + resp.sOn_Item = character->sOn_Item; loginSessions[sock].characters[UID] = Player(); loginSessions[sock].characters[UID].level = 1; @@ -231,7 +231,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { loginSessions[sock].characters[UID].Equip[3].iType = 3; loginSessions[sock].characters[UID].IsGM = false; - sock->sendPacket(new CNPacketData((void*)response, P_LS2CL_REP_CHAR_CREATE_SUCC, sizeof(sP_LS2CL_REP_CHAR_CREATE_SUCC), sock->getEKey())); + sock->sendPacket((void*)&resp, P_LS2CL_REP_CHAR_CREATE_SUCC, sizeof(sP_LS2CL_REP_CHAR_CREATE_SUCC)); break; } case P_CL2LS_REQ_CHAR_SELECT: { @@ -240,7 +240,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { // character selected sP_CL2LS_REQ_CHAR_SELECT* chararacter = (sP_CL2LS_REQ_CHAR_SELECT*)data->buf; - sP_LS2CL_REP_CHAR_SELECT_SUCC* response = (sP_LS2CL_REP_CHAR_SELECT_SUCC*)xmalloc(sizeof(sP_LS2CL_REP_CHAR_SELECT_SUCC)); + sP_LS2CL_REP_CHAR_SELECT_SUCC resp; DEBUGLOG( std::cout << "P_CL2LS_REQ_CHAR_SELECT:" << std::endl; @@ -249,7 +249,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { loginSessions[sock].selectedChar = chararacter->iPC_UID; - sock->sendPacket(new CNPacketData((void*)response, P_LS2CL_REP_CHAR_SELECT_SUCC, sizeof(sP_LS2CL_REP_CHAR_SELECT_SUCC), sock->getEKey())); + sock->sendPacket((void*)&resp, P_LS2CL_REP_CHAR_SELECT_SUCC, sizeof(sP_LS2CL_REP_CHAR_SELECT_SUCC)); break; } case P_CL2LS_REQ_SHARD_SELECT: { @@ -258,7 +258,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { // tell client to connect to the shard server sP_CL2LS_REQ_SHARD_SELECT* shard = (sP_CL2LS_REQ_SHARD_SELECT*)data->buf; - sP_LS2CL_REP_SHARD_SELECT_SUCC* response = (sP_LS2CL_REP_SHARD_SELECT_SUCC*)xmalloc(sizeof(sP_LS2CL_REP_SHARD_SELECT_SUCC)); + sP_LS2CL_REP_SHARD_SELECT_SUCC resp; DEBUGLOG( std::cout << "P_CL2LS_REQ_SHARD_SELECT:" << std::endl; @@ -266,17 +266,17 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { ) const char* SHARD_IP = settings::SHARDSERVERIP.c_str(); - response->iEnterSerialKey = rand(); - response->g_FE_ServerPort = settings::SHARDPORT; + resp.iEnterSerialKey = rand(); + resp.g_FE_ServerPort = settings::SHARDPORT; - // copy IP to response (this struct uses ASCII encoding so we don't have to goof around converting encodings) - memcpy(response->g_FE_ServerIP, SHARD_IP, strlen(SHARD_IP)); - response->g_FE_ServerIP[strlen(SHARD_IP)] = '\0'; + // copy IP to resp (this struct uses ASCII encoding so we don't have to goof around converting encodings) + memcpy(resp.g_FE_ServerIP, SHARD_IP, strlen(SHARD_IP)); + resp.g_FE_ServerIP[strlen(SHARD_IP)] = '\0'; // pass player to CNSharedData - CNSharedData::setPlayer(response->iEnterSerialKey, loginSessions[sock].characters[loginSessions[sock].selectedChar]); + CNSharedData::setPlayer(resp.iEnterSerialKey, loginSessions[sock].characters[loginSessions[sock].selectedChar]); - sock->sendPacket(new CNPacketData((void*)response, P_LS2CL_REP_SHARD_SELECT_SUCC, sizeof(sP_LS2CL_REP_SHARD_SELECT_SUCC), sock->getEKey())); + sock->sendPacket((void*)&resp, P_LS2CL_REP_SHARD_SELECT_SUCC, sizeof(sP_LS2CL_REP_SHARD_SELECT_SUCC)); sock->kill(); // client should connect to the Shard server now break; } @@ -286,6 +286,10 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { } } +void CNLoginServer::newConnection(CNSocket* cns) { + cns->setActiveKey(SOCKETKEY_E); // by default they accept keys encrypted with the default key +} + void CNLoginServer::killConnection(CNSocket* cns) { loginSessions.erase(cns); } diff --git a/src/CNLoginServer.hpp b/src/CNLoginServer.hpp index 3ff0b97..e694588 100644 --- a/src/CNLoginServer.hpp +++ b/src/CNLoginServer.hpp @@ -21,6 +21,7 @@ private: public: CNLoginServer(uint16_t p); + void newConnection(CNSocket* cns); void killConnection(CNSocket* cns); }; diff --git a/src/CNProtocol.cpp b/src/CNProtocol.cpp index ce76875..8b9a5dc 100644 --- a/src/CNProtocol.cpp +++ b/src/CNProtocol.cpp @@ -63,11 +63,7 @@ int CNSocketEncryption::decryptData(uint8_t* buffer, uint8_t* key, int size) { // ========================================================[[ CNPacketData ]]======================================================== -CNPacketData::CNPacketData(void* b, uint32_t t, int l, uint64_t k): buf(b), type(t), size(l), key(k) {} - -CNPacketData::~CNPacketData() { - free(buf); // we own the buffer -} +CNPacketData::CNPacketData(void* b, uint32_t t, int l): buf(b), type(t), size(l) {} // ========================================================[[ CNSocket ]]======================================================== @@ -126,21 +122,34 @@ void CNSocket::kill() { #endif } -void CNSocket::sendPacket(CNPacketData* pak) { - if (!alive) { - delete pak; +// we don't own buf +void CNSocket::sendPacket(void* buf, uint32_t type, size_t size) { + if (!alive) return; - } - int tmpSize = pak->size + sizeof(uint32_t); + int tmpSize = size + sizeof(uint32_t); uint8_t* tmpBuf = (uint8_t*)xmalloc(tmpSize); // copy packet type to the front of the buffer & then the actual buffer - memcpy(tmpBuf, (void*)&pak->type, sizeof(uint32_t)); - memcpy(tmpBuf+sizeof(uint32_t), pak->buf, pak->size); + memcpy(tmpBuf, (void*)&type, sizeof(uint32_t)); + memcpy(tmpBuf+sizeof(uint32_t), buf, size); // encrypt the packet - CNSocketEncryption::encryptData((uint8_t*)tmpBuf, (uint8_t*)(&pak->key), tmpSize); + switch (activeKey) { + case SOCKETKEY_E: + CNSocketEncryption::encryptData((uint8_t*)tmpBuf, (uint8_t*)(&EKey), tmpSize); + break; + case SOCKETKEY_FE: + CNSocketEncryption::encryptData((uint8_t*)tmpBuf, (uint8_t*)(&FEKey), tmpSize); + break; + default: { + free(tmpBuf); + DEBUGLOG( + std::cout << "[WARN]: UNSET KEYTYPE FOR SOCKET!! ABORTING SEND" << std::endl; + ) + return; + } + } // send packet size if (!sendData((uint8_t*)&tmpSize, sizeof(uint32_t))) @@ -150,10 +159,13 @@ void CNSocket::sendPacket(CNPacketData* pak) { if (alive && !sendData(tmpBuf, tmpSize)) kill(); - delete pak; free(tmpBuf); // free tmp buffer } +void CNSocket::setActiveKey(ACTIVEKEY key) { + activeKey = key; +} + void CNSocket::step() { if (readSize <= 0) { // we aren't reading a packet yet, try to start looking for one @@ -183,13 +195,15 @@ void CNSocket::step() { // decrypt readBuffer and copy to CNPacketData CNSocketEncryption::decryptData(readBuffer, (uint8_t*)(&EKey), readSize); - // this doesn't leak memory because we free it in CNPacketData's deconstructor LOL void* tmpBuf = xmalloc(readSize-sizeof(int32_t)); memcpy(tmpBuf, readBuffer+sizeof(uint32_t), readSize-sizeof(int32_t)); - CNPacketData tmp(tmpBuf, *((uint32_t*)readBuffer), readSize-sizeof(int32_t), EKey); + CNPacketData tmp(tmpBuf, *((uint32_t*)readBuffer), readSize-sizeof(int32_t)); - // CALL PACKET HANDLER!! - pHandler(this, &tmp); // tmp's deconstructor will be called when readStep returns so that tmpBuffer we made will be cleaned up :) + // call packet handler!! + pHandler(this, &tmp); + + // clean up the buffer :) + free(tmpBuf); // reset vars :) readSize = 0; @@ -261,22 +275,22 @@ void CNServer::start() { std::lock_guard lock(activeCrit); // listen for a new connection - SOCKET newConnection = accept(sock, (struct sockaddr *)&(address), (socklen_t*)&(addressSize)); - if (!SOCKETINVALID(newConnection)) { + SOCKET newConnectionSocket = accept(sock, (struct sockaddr *)&(address), (socklen_t*)&(addressSize)); + if (!SOCKETINVALID(newConnectionSocket)) { // new connection! make sure to set non-blocking! #ifdef _WIN32 unsigned long mode = 1; - if (ioctlsocket(newConnection, FIONBIO, &mode) != 0) { + if (ioctlsocket(newConnectionSocket, FIONBIO, &mode) != 0) { #else - if (fcntl(newConnection, F_SETFL, (fcntl(sock, F_GETFL, 0) | O_NONBLOCK)) != 0) { + if (fcntl(newConnectionSocket, F_SETFL, (fcntl(sock, F_GETFL, 0) | O_NONBLOCK)) != 0) { #endif std::cerr << "[WARN] OpenFusion: fcntl failed on new connection" << std::endl; #ifdef _WIN32 - shutdown(newConnection, SD_BOTH); - closesocket(newConnection); + shutdown(newConnectionSocket, SD_BOTH); + closesocket(newConnectionSocket); #else - shutdown(newConnection, SHUT_RDWR); - close(newConnection); + shutdown(newConnectionSocket, SHUT_RDWR); + close(newConnectionSocket); #endif continue; } @@ -284,8 +298,9 @@ void CNServer::start() { std::cout << "New connection! " << inet_ntoa(address.sin_addr) << std::endl; // add connection to list! - CNSocket* tmp = new CNSocket(newConnection, pHandler); + CNSocket* tmp = new CNSocket(newConnectionSocket, pHandler); connections.push_back(tmp); + newConnection(tmp); } // for each connection, check if it's alive, if not kill it! @@ -337,5 +352,6 @@ void CNServer::kill() { connections.clear(); } -void CNServer::killConnection(CNSocket* cns) {} // stubbed lol -void CNServer::onTimer() {} // stubbed lol +void CNServer::newConnection(CNSocket* cns) {} // stubbed +void CNServer::killConnection(CNSocket* cns) {} // stubbed +void CNServer::onTimer() {} // stubbed diff --git a/src/CNProtocol.hpp b/src/CNProtocol.hpp index 8f87962..3913a75 100644 --- a/src/CNProtocol.hpp +++ b/src/CNProtocol.hpp @@ -77,15 +77,17 @@ namespace CNSocketEncryption { int decryptData(uint8_t* buffer, uint8_t* key, int size); } -class CNPacketData { -public: +struct CNPacketData { void* buf; int size; uint32_t type; - uint64_t key; - CNPacketData(void* b, uint32_t t, int l, uint64_t k); - ~CNPacketData(); + CNPacketData(void* b, uint32_t t, int l); +}; + +enum ACTIVEKEY { + SOCKETKEY_E, + SOCKETKEY_FE }; class CNSocket; @@ -101,6 +103,8 @@ private: bool activelyReading = false; bool alive = true; + ACTIVEKEY activeKey; + bool sendData(uint8_t* data, int size); public: @@ -113,9 +117,10 @@ public: void setFEKey(uint64_t k); uint64_t getEKey(); uint64_t getFEKey(); + void setActiveKey(ACTIVEKEY t); void kill(); - void sendPacket(CNPacketData* pak); + void sendPacket(void* buf, uint32_t packetType, size_t size); void step(); bool isAlive(); }; @@ -143,6 +148,7 @@ public: void start(); void kill(); + virtual void newConnection(CNSocket* cns); virtual void killConnection(CNSocket* cns); virtual void onTimer(); // called every 2 seconds }; diff --git a/src/CNShardServer.cpp b/src/CNShardServer.cpp index e603d01..de30956 100644 --- a/src/CNShardServer.cpp +++ b/src/CNShardServer.cpp @@ -28,6 +28,10 @@ void CNShardServer::handlePacket(CNSocket* sock, CNPacketData* data) { std::cerr << "OpenFusion: SHARD UNIMPLM ERR. PacketType: " << Defines::p2str(CL2FE, data->type) << " (" << data->type << ")" << std::endl; } +void CNShardServer::newConnection(CNSocket* cns) { + cns->setActiveKey(SOCKETKEY_E); // by default they accept keys encrypted with the default key +} + void CNShardServer::killConnection(CNSocket* cns) { // remove from CNSharedData Player cachedPlr = PlayerManager::getPlayer(cns); @@ -48,7 +52,7 @@ void CNShardServer::onTimer() { } // passed the heartbeat, send another - sP_FE2CL_REQ_LIVE_CHECK* data = (sP_FE2CL_REQ_LIVE_CHECK*)xmalloc(sizeof(sP_FE2CL_REQ_LIVE_CHECK)); - pair.first->sendPacket(new CNPacketData((void*)data, P_FE2CL_REQ_LIVE_CHECK, sizeof(sP_FE2CL_REQ_LIVE_CHECK), pair.first->getFEKey())); + sP_FE2CL_REQ_LIVE_CHECK data; + pair.first->sendPacket((void*)&data, P_FE2CL_REQ_LIVE_CHECK, sizeof(sP_FE2CL_REQ_LIVE_CHECK)); } } diff --git a/src/CNShardServer.hpp b/src/CNShardServer.hpp index 93c73cc..e9d9b56 100644 --- a/src/CNShardServer.hpp +++ b/src/CNShardServer.hpp @@ -17,6 +17,7 @@ public: CNShardServer(uint16_t p); + void newConnection(CNSocket* cns); void killConnection(CNSocket* cns); void onTimer(); }; diff --git a/src/ChatManager.cpp b/src/ChatManager.cpp index f786c95..e9b5318 100644 --- a/src/ChatManager.cpp +++ b/src/ChatManager.cpp @@ -16,21 +16,18 @@ void ChatManager::chatHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // send to client - sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC* resp = (sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC)); - memcpy(resp->szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); - resp->iPC_ID = PlayerManager::players[sock].plr.iID; - resp->iEmoteCode = chat->iEmoteCode; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC), sock->getFEKey())); + sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC resp; + memcpy(resp.szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); + resp.iPC_ID = plr.plr.iID; + resp.iEmoteCode = chat->iEmoteCode; + sock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC)); // send to visible players for (CNSocket* otherSock : plr.viewable) { - sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC* resp = (sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC)); - memcpy(resp->szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); - resp->iPC_ID = PlayerManager::players[sock].plr.iID; - resp->iEmoteCode = chat->iEmoteCode; - otherSock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC), otherSock->getFEKey())); + otherSock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC)); } } + void ChatManager::menuChatHandler(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE)) return; // malformed packet @@ -38,19 +35,15 @@ void ChatManager::menuChatHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // send to client - sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC* resp = (sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC)); - memcpy(resp->szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); - resp->iPC_ID = PlayerManager::players[sock].plr.iID; - resp->iEmoteCode = chat->iEmoteCode; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC), sock->getFEKey())); + sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC resp; + memcpy(resp.szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); + resp.iPC_ID = plr.plr.iID; + resp.iEmoteCode = chat->iEmoteCode; + sock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC)); // send to visible players for (CNSocket* otherSock : plr.viewable) { - sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC* resp = (sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC)); - memcpy(resp->szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); - resp->iPC_ID = PlayerManager::players[sock].plr.iID; - resp->iEmoteCode = chat->iEmoteCode; - otherSock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC), otherSock->getFEKey())); + otherSock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC)); } } void ChatManager::emoteHandler(CNSocket* sock, CNPacketData* data) { @@ -63,16 +56,13 @@ void ChatManager::emoteHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // send to client - sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT* resp = (sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT*)xmalloc(sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT)); - resp->iEmoteCode = emote->iEmoteCode; - resp->iID_From = plr.plr.iID; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT), sock->getFEKey())); + sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT resp; + resp.iEmoteCode = emote->iEmoteCode; + resp.iID_From = plr.plr.iID; + sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT)); // send to visible players (players within render distance) for (CNSocket* otherSock : plr.viewable) { - resp = (sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT*)xmalloc(sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT)); - resp->iEmoteCode = emote->iEmoteCode; - resp->iID_From = plr.plr.iID; - otherSock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT), otherSock->getFEKey())); + otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT)); } } diff --git a/src/ItemManager.cpp b/src/ItemManager.cpp index 0525e1f..47c6e53 100644 --- a/src/ItemManager.cpp +++ b/src/ItemManager.cpp @@ -15,7 +15,7 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_ITEM_MOVE* itemmove = (sP_CL2FE_REQ_ITEM_MOVE*)data->buf; - sP_FE2CL_PC_ITEM_MOVE_SUCC* resp = (sP_FE2CL_PC_ITEM_MOVE_SUCC*)xmalloc(sizeof(sP_FE2CL_PC_ITEM_MOVE_SUCC)); + sP_FE2CL_PC_ITEM_MOVE_SUCC resp; PlayerView& plr = PlayerManager::players[sock]; sItemBase fromItem; @@ -46,29 +46,31 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) { } if (itemmove->eFrom == 0 || itemmove->eTo == 0) { - for (CNSocket* otherSock : plr.viewable) { - sP_FE2CL_PC_EQUIP_CHANGE* resp2 = (sP_FE2CL_PC_EQUIP_CHANGE*)xmalloc(sizeof(sP_FE2CL_PC_EQUIP_CHANGE)); + sP_FE2CL_PC_EQUIP_CHANGE equipChange; - resp2->iPC_ID = plr.plr.iID; - if (itemmove->eFrom == 0) { - resp2->iEquipSlotNum = itemmove->iFromSlotNum; - resp2->EquipSlotItem = toItem; - } else { - resp2->iEquipSlotNum = itemmove->iToSlotNum; - resp2->EquipSlotItem = fromItem; - } - otherSock->sendPacket(new CNPacketData((void*)resp2, P_FE2CL_PC_EQUIP_CHANGE, sizeof(sP_FE2CL_PC_EQUIP_CHANGE), otherSock->getFEKey())); + equipChange.iPC_ID = plr.plr.iID; + if (itemmove->eFrom == 0) { + equipChange.iEquipSlotNum = itemmove->iFromSlotNum; + equipChange.EquipSlotItem = toItem; + } else { + equipChange.iEquipSlotNum = itemmove->iToSlotNum; + equipChange.EquipSlotItem = fromItem; + } + + // send equip event to other players + for (CNSocket* otherSock : plr.viewable) { + otherSock->sendPacket((void*)&equipChange, P_FE2CL_PC_EQUIP_CHANGE, sizeof(sP_FE2CL_PC_EQUIP_CHANGE)); } } - resp->eTo = itemmove->eFrom; - resp->iToSlotNum = itemmove->iFromSlotNum; - resp->ToSlotItem = toItem; - resp->eFrom = itemmove->eTo; - resp->iFromSlotNum = itemmove->iToSlotNum; - resp->FromSlotItem = fromItem; + resp.eTo = itemmove->eFrom; + resp.iToSlotNum = itemmove->iFromSlotNum; + resp.ToSlotItem = toItem; + resp.eFrom = itemmove->eTo; + resp.iFromSlotNum = itemmove->iToSlotNum; + resp.FromSlotItem = fromItem; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_PC_ITEM_MOVE_SUCC, sizeof(sP_FE2CL_PC_ITEM_MOVE_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&resp, P_FE2CL_PC_ITEM_MOVE_SUCC, sizeof(sP_FE2CL_PC_ITEM_MOVE_SUCC)); } void ItemManager::itemDeleteHandler(CNSocket* sock, CNPacketData* data) { @@ -76,19 +78,19 @@ void ItemManager::itemDeleteHandler(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_ITEM_DELETE* itemdel = (sP_CL2FE_REQ_PC_ITEM_DELETE*)data->buf; - sP_FE2CL_REP_PC_ITEM_DELETE_SUCC* resp = (sP_FE2CL_REP_PC_ITEM_DELETE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC)); + sP_FE2CL_REP_PC_ITEM_DELETE_SUCC resp; PlayerView& plr = PlayerManager::players[sock]; - resp->eIL = itemdel->eIL; - resp->iSlotNum = itemdel->iSlotNum; + resp.eIL = itemdel->eIL; + resp.iSlotNum = itemdel->iSlotNum; // so, im not sure what this eIL thing does since you always delete items in inventory and not equips plr.plr.Inven[itemdel->iSlotNum].iID = 0; plr.plr.Inven[itemdel->iSlotNum].iType = 0; plr.plr.Inven[itemdel->iSlotNum].iOpt = 0; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_ITEM_DELETE_SUCC, sizeof(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_ITEM_DELETE_SUCC, sizeof(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC)); } void ItemManager::itemGMGiveHandler(CNSocket* sock, CNPacketData* data) { @@ -108,22 +110,24 @@ void ItemManager::itemGMGiveHandler(CNSocket* sock, CNPacketData* data) { // Quest item, not a real item, handle this later, stubbed for now // sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_GIVE_ITEM_FAIL, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_FAIL), sock->getFEKey())); } else if (itemreq->eIL == 1) { - sP_FE2CL_REP_PC_GIVE_ITEM_SUCC* resp = (sP_FE2CL_REP_PC_GIVE_ITEM_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC)); + sP_FE2CL_REP_PC_GIVE_ITEM_SUCC resp; - resp->eIL = itemreq->eIL; - resp->iSlotNum = itemreq->iSlotNum; - resp->Item = itemreq->Item; + resp.eIL = itemreq->eIL; + resp.iSlotNum = itemreq->iSlotNum; + resp.Item = itemreq->Item; plr.plr.Inven[itemreq->iSlotNum] = itemreq->Item; plr.plr.level = 36; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC)); - sP_FE2CL_REP_PC_CHANGE_LEVEL* resp2 = (sP_FE2CL_REP_PC_CHANGE_LEVEL*)xmalloc(sizeof(sP_FE2CL_REP_PC_CHANGE_LEVEL)); + // some items require a level, for now we're just going to bypass this by setting your level to 36 + + sP_FE2CL_REP_PC_CHANGE_LEVEL resp2; - resp2->iPC_ID = plr.plr.iID; - resp2->iPC_Level = 36; + resp2.iPC_ID = plr.plr.iID; + resp2.iPC_Level = 36; - sock->sendPacket(new CNPacketData((void*)resp2, P_FE2CL_REP_PC_CHANGE_LEVEL, sizeof(sP_FE2CL_REP_PC_CHANGE_LEVEL), sock->getFEKey())); + sock->sendPacket((void*)&resp2, P_FE2CL_REP_PC_CHANGE_LEVEL, sizeof(sP_FE2CL_REP_PC_CHANGE_LEVEL)); } } \ No newline at end of file diff --git a/src/NPCManager.cpp b/src/NPCManager.cpp index 52cc07e..094b58f 100644 --- a/src/NPCManager.cpp +++ b/src/NPCManager.cpp @@ -49,17 +49,16 @@ void NPCManager::updatePlayerNPCS(CNSocket* sock, PlayerView& view) { } } + sP_FE2CL_NPC_EXIT exitData; std::list::iterator i = view.viewableNPCs.begin(); while (i != view.viewableNPCs.end()) { int32_t id = *i; if (std::find(noView.begin(), noView.end(), id) != noView.end()) { // it shouldn't be visible, send NPC_EXIT - sP_FE2CL_NPC_EXIT* exitData = (sP_FE2CL_NPC_EXIT*)xmalloc(sizeof(sP_FE2CL_NPC_EXIT)); - exitData->iNPC_ID = id; - - sock->sendPacket(new CNPacketData((void*)exitData, P_FE2CL_NPC_EXIT, sizeof(sP_FE2CL_NPC_EXIT), sock->getFEKey())); + exitData.iNPC_ID = id; + sock->sendPacket((void*)&exitData, P_FE2CL_NPC_EXIT, sizeof(sP_FE2CL_NPC_EXIT)); // remove from view view.viewableNPCs.erase(i++); @@ -68,16 +67,15 @@ void NPCManager::updatePlayerNPCS(CNSocket* sock, PlayerView& view) { ++i; } + sP_FE2CL_NPC_ENTER enterData; for (int32_t id : yesView) { if (std::find(view.viewableNPCs.begin(), view.viewableNPCs.end(), id) == view.viewableNPCs.end()) { - // needs to be added to viewableNPCs! send NPC_ENTER - sP_FE2CL_NPC_ENTER* enterData = (sP_FE2CL_NPC_ENTER*)xmalloc(sizeof(sP_FE2CL_NPC_ENTER)); - enterData->NPCAppearanceData = NPCs[id].appearanceData; - - sock->sendPacket(new CNPacketData((void*)enterData, P_FE2CL_NPC_ENTER, sizeof(sP_FE2CL_NPC_ENTER), sock->getFEKey())); + enterData.NPCAppearanceData = NPCs[id].appearanceData; + sock->sendPacket((void*)&enterData, P_FE2CL_NPC_ENTER, sizeof(sP_FE2CL_NPC_ENTER)); + // add to viewable view.viewableNPCs.push_back(id); } } diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index c692060..c293a7f 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -17,11 +17,12 @@ void NanoManager::nanoEquipHandler(CNSocket* sock, CNPacketData* data) { return; // malformed packet sP_CL2FE_REQ_NANO_EQUIP* nano = (sP_CL2FE_REQ_NANO_EQUIP*)data->buf; - sP_FE2CL_REP_NANO_EQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_EQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC)); - resp->iNanoID = nano->iNanoID; - resp->iNanoSlotNum = nano->iNanoSlotNum; + sP_FE2CL_REP_NANO_EQUIP_SUCC resp; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_EQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC), sock->getFEKey())); + resp.iNanoID = nano->iNanoID; + resp.iNanoSlotNum = nano->iNanoSlotNum; + + sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_EQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC)); } void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) { @@ -29,10 +30,11 @@ void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) { return; // malformed packet sP_CL2FE_REQ_NANO_UNEQUIP* nano = (sP_CL2FE_REQ_NANO_UNEQUIP*)data->buf; - sP_FE2CL_REP_NANO_UNEQUIP_SUCC* resp = (sP_FE2CL_REP_NANO_UNEQUIP_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC)); - resp->iNanoSlotNum = nano->iNanoSlotNum; + sP_FE2CL_REP_NANO_UNEQUIP_SUCC resp; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_UNEQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC), sock->getFEKey())); + resp.iNanoSlotNum = nano->iNanoSlotNum; + + sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_UNEQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC)); } void NanoManager::nanoGMGiveHandler(CNSocket* sock, CNPacketData* data) { @@ -59,9 +61,9 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // Send to client - sP_FE2CL_REP_NANO_ACTIVE_SUCC* resp = (sP_FE2CL_REP_NANO_ACTIVE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC)); - resp->iActiveNanoSlotNum = nano->iNanoSlotNum; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC), sock->getFEKey())); + sP_FE2CL_REP_NANO_ACTIVE_SUCC resp; + resp.iActiveNanoSlotNum = nano->iNanoSlotNum; + sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC)); DEBUGLOG( std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; @@ -76,16 +78,16 @@ void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // Send to client - sP_FE2CL_NANO_SKILL_USE_SUCC* resp = (sP_FE2CL_NANO_SKILL_USE_SUCC*)xmalloc(sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC)); - resp->iArg1 = skill->iArg1; - resp->iArg2 = skill->iArg2; - resp->iArg3 = skill->iArg3; - resp->iBulletID = skill->iBulletID; - resp->iTargetCnt = skill->iTargetCnt; - resp->iPC_ID = plr.plr.iID; - resp->iNanoStamina = 150; // Hardcoded for now + sP_FE2CL_NANO_SKILL_USE_SUCC resp; + resp.iArg1 = skill->iArg1; + resp.iArg2 = skill->iArg2; + resp.iArg3 = skill->iArg3; + resp.iBulletID = skill->iBulletID; + resp.iTargetCnt = skill->iTargetCnt; + resp.iPC_ID = plr.plr.iID; + resp.iNanoStamina = 150; // Hardcoded for now - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC)); DEBUGLOG( std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; @@ -105,15 +107,15 @@ void NanoManager::addNano(CNSocket* sock, int16_t nanoId, int16_t slot) { Player plr = PlayerManager::getPlayer(sock); // Send to client - sP_FE2CL_REP_PC_NANO_CREATE_SUCC* resp = new sP_FE2CL_REP_PC_NANO_CREATE_SUCC(); - resp->Nano.iID = nanoId; - resp->Nano.iStamina = 150; - resp->iQuestItemSlotNum = slot; + sP_FE2CL_REP_PC_NANO_CREATE_SUCC resp; + resp.Nano.iID = nanoId; + resp.Nano.iStamina = 150; + resp.iQuestItemSlotNum = slot; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_NANO_CREATE_SUCC, sizeof(sP_FE2CL_REP_PC_NANO_CREATE_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_NANO_CREATE_SUCC, sizeof(sP_FE2CL_REP_PC_NANO_CREATE_SUCC)); // Update player - plr.Nanos[nanoId] = resp->Nano; + plr.Nanos[nanoId] = resp.Nano; PlayerManager::updatePlayer(sock, plr); } @@ -125,11 +127,11 @@ void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) plr.Nanos[nanoId] = nano; // Send to client - sP_FE2CL_REP_NANO_TUNE_SUCC* resp = (sP_FE2CL_REP_NANO_TUNE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC)); - resp->iNanoID = nanoId; - resp->iSkillID = skillId; + sP_FE2CL_REP_NANO_TUNE_SUCC resp; + resp.iNanoID = nanoId; + resp.iSkillID = skillId; - sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC)); DEBUGLOG( std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl; diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index f956bbc..c246d19 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -48,10 +48,10 @@ void PlayerManager::removePlayer(CNSocket* key) { players[otherSock].viewable.remove(key); // gone // now sent PC_EXIT packet - sP_FE2CL_PC_EXIT* exitPacket = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); - exitPacket->iID = players[key].plr.iID; + sP_FE2CL_PC_EXIT exitPacket; + exitPacket.iID = players[key].plr.iID; - otherSock->sendPacket(new CNPacketData((void*)exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), otherSock->getFEKey())); + otherSock->sendPacket((void*)&exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT)); } players.erase(key); @@ -88,21 +88,20 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { } } + sP_FE2CL_PC_EXIT exitPacket; + std::list::iterator i = players[sock].viewable.begin(); while (i != players[sock].viewable.end()) { CNSocket* otherSock = *i; if (std::find(noView.begin(), noView.end(), otherSock) != noView.end()) { - // sock shouldn't be visible, send PC_EXIT packet & remove them - sP_FE2CL_PC_EXIT* exitPacket = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); - sP_FE2CL_PC_EXIT* exitPacketOther = (sP_FE2CL_PC_EXIT*)xmalloc(sizeof(sP_FE2CL_PC_EXIT)); - - exitPacket->iID = players[sock].plr.iID; - exitPacketOther->iID = players[otherSock].plr.iID; - - otherSock->sendPacket(new CNPacketData((void*)exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), otherSock->getFEKey())); - sock->sendPacket(new CNPacketData((void*)exitPacketOther, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT), sock->getFEKey())); + // sock shouldn't be visible, send PC_EXIT packet + exitPacket.iID = players[sock].plr.iID; + otherSock->sendPacket((void*)&exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT)); + exitPacket.iID = players[otherSock].plr.iID; + sock->sendPacket((void*)&exitPacket, P_FE2CL_PC_EXIT, sizeof(sP_FE2CL_PC_EXIT)); + // remove them from the viewable list players[sock].viewable.erase(i++); players[otherSock].viewable.remove(sock); continue; @@ -111,38 +110,37 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { ++i; } + sP_FE2CL_PC_NEW newPlayer; for (CNSocket* otherSock : yesView) { if (std::find(players[sock].viewable.begin(), players[sock].viewable.end(), otherSock) == players[sock].viewable.end()) { // this needs to be added to the viewable players, send PC_ENTER - sP_FE2CL_PC_NEW* newPlayer = (sP_FE2CL_PC_NEW*)xmalloc(sizeof(sP_FE2CL_PC_NEW)); // current connection to other player - sP_FE2CL_PC_NEW* newOtherPlayer = (sP_FE2CL_PC_NEW*)xmalloc(sizeof(sP_FE2CL_PC_NEW)); // other player to current connection - Player otherPlr = players[otherSock].plr; Player plr = players[sock].plr; - newPlayer->PCAppearanceData.iID = plr.iID; - newPlayer->PCAppearanceData.iHP = plr.HP; - newPlayer->PCAppearanceData.iLv = plr.level; - newPlayer->PCAppearanceData.iX = plr.x; - newPlayer->PCAppearanceData.iY = plr.y; - newPlayer->PCAppearanceData.iZ = plr.z; - newPlayer->PCAppearanceData.iAngle = plr.angle; - newPlayer->PCAppearanceData.PCStyle = plr.PCStyle; - memcpy(newPlayer->PCAppearanceData.ItemEquip, plr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); + newPlayer.PCAppearanceData.iID = plr.iID; + newPlayer.PCAppearanceData.iHP = plr.HP; + newPlayer.PCAppearanceData.iLv = plr.level; + newPlayer.PCAppearanceData.iX = plr.x; + newPlayer.PCAppearanceData.iY = plr.y; + newPlayer.PCAppearanceData.iZ = plr.z; + newPlayer.PCAppearanceData.iAngle = plr.angle; + newPlayer.PCAppearanceData.PCStyle = plr.PCStyle; + memcpy(newPlayer.PCAppearanceData.ItemEquip, plr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); - newOtherPlayer->PCAppearanceData.iID = otherPlr.iID; - newOtherPlayer->PCAppearanceData.iHP = otherPlr.HP; - newOtherPlayer->PCAppearanceData.iLv = otherPlr.level; - newOtherPlayer->PCAppearanceData.iX = otherPlr.x; - newOtherPlayer->PCAppearanceData.iY = otherPlr.y; - newOtherPlayer->PCAppearanceData.iZ = otherPlr.z; - newOtherPlayer->PCAppearanceData.iAngle = otherPlr.angle; - newOtherPlayer->PCAppearanceData.PCStyle = otherPlr.PCStyle; - memcpy(newOtherPlayer->PCAppearanceData.ItemEquip, otherPlr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); + otherSock->sendPacket((void*)&newPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW)); - sock->sendPacket(new CNPacketData((void*)newOtherPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW), sock->getFEKey())); - otherSock->sendPacket(new CNPacketData((void*)newPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW), otherSock->getFEKey())); + newPlayer.PCAppearanceData.iID = otherPlr.iID; + newPlayer.PCAppearanceData.iHP = otherPlr.HP; + newPlayer.PCAppearanceData.iLv = otherPlr.level; + newPlayer.PCAppearanceData.iX = otherPlr.x; + newPlayer.PCAppearanceData.iY = otherPlr.y; + newPlayer.PCAppearanceData.iZ = otherPlr.z; + newPlayer.PCAppearanceData.iAngle = otherPlr.angle; + newPlayer.PCAppearanceData.PCStyle = otherPlr.PCStyle; + memcpy(newPlayer.PCAppearanceData.ItemEquip, otherPlr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); + + sock->sendPacket((void*)&newPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW)); players[sock].viewable.push_back(otherSock); players[otherSock].viewable.push_back(sock); @@ -157,8 +155,8 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_ENTER* enter = (sP_CL2FE_REQ_PC_ENTER*)data->buf; - sP_FE2CL_REP_PC_ENTER_SUCC* response = (sP_FE2CL_REP_PC_ENTER_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_ENTER_SUCC)); - sP_FE2CL_PC_MOTD_LOGIN* motd = (sP_FE2CL_PC_MOTD_LOGIN*)xmalloc(sizeof(sP_FE2CL_PC_MOTD_LOGIN)); + sP_FE2CL_REP_PC_ENTER_SUCC response; + sP_FE2CL_PC_MOTD_LOGIN motd; // TODO: check if serialkey exists, if it doesn't send sP_FE2CL_REP_PC_ENTER_FAIL Player plr = CNSharedData::getPlayer(enter->iEnterSerialKey); @@ -171,69 +169,57 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { std::cout << "\tPC_UID: " << plr.PCStyle.iPC_UID << std::endl; ) - response->iID = rand(); - response->uiSvrTime = getTime(); - response->PCLoadData2CL.iUserLevel = 1; - response->PCLoadData2CL.iHP = 1000 * plr.level; - response->PCLoadData2CL.iLevel = plr.level; - response->PCLoadData2CL.iMentor = 1; - response->PCLoadData2CL.iMentorCount = 4; - response->PCLoadData2CL.iMapNum = 0; - response->PCLoadData2CL.iX = plr.x; - response->PCLoadData2CL.iY = plr.y; - response->PCLoadData2CL.iZ = plr.z; - response->PCLoadData2CL.iActiveNanoSlotNum = -1; - response->PCLoadData2CL.iFatigue = 50; - response->PCLoadData2CL.PCStyle = plr.PCStyle; - response->PCLoadData2CL.PCStyle2 = plr.PCStyle2; + response.iID = rand(); + response.uiSvrTime = getTime(); + response.PCLoadData2CL.iUserLevel = 1; + response.PCLoadData2CL.iHP = 1000 * plr.level; + response.PCLoadData2CL.iLevel = plr.level; + response.PCLoadData2CL.iMentor = 1; + response.PCLoadData2CL.iMentorCount = 4; + response.PCLoadData2CL.iMapNum = 0; + response.PCLoadData2CL.iX = plr.x; + response.PCLoadData2CL.iY = plr.y; + response.PCLoadData2CL.iZ = plr.z; + response.PCLoadData2CL.iActiveNanoSlotNum = -1; + response.PCLoadData2CL.iFatigue = 50; + response.PCLoadData2CL.PCStyle = plr.PCStyle; + response.PCLoadData2CL.PCStyle2 = plr.PCStyle2; for (int i = 0; i < AEQUIP_COUNT; i++) - response->PCLoadData2CL.aEquip[i] = plr.Equip[i]; + response.PCLoadData2CL.aEquip[i] = plr.Equip[i]; - // protocol-agnostic sItemBase usage - sItemBase item; - memset(&item, 0, sizeof(sItemBase)); - item.iID = 495; - - for (int i = 0; i < AINVEN_COUNT; i++) { - switch (i) { - case 6: case 8: case 11: case 13: case 20: - case 24: case 26: case 27: case 28: - plr.Inven[i] = item; - break; - default: - memset(&plr.Inven[i], 0, sizeof(sItemBase)); - } - response->PCLoadData2CL.aInven[i] = plr.Inven[i]; - } + for (int i = 0; i < AINVEN_COUNT; i++) + response.PCLoadData2CL.aInven[i] = plr.Inven[i]; // don't ask.. for (int i = 1; i < 37; i++) { - response->PCLoadData2CL.aNanoBank[i].iID = i; - response->PCLoadData2CL.aNanoBank[i].iSkillID = 1; - response->PCLoadData2CL.aNanoBank[i].iStamina = 150; + response.PCLoadData2CL.aNanoBank[i].iID = i; + response.PCLoadData2CL.aNanoBank[i].iSkillID = 1; + response.PCLoadData2CL.aNanoBank[i].iStamina = 150; } // temporarily not add nanos for nano add test through commands - //response->PCLoadData2CL.aNanoSlots[0] = 1; - //response->PCLoadData2CL.aNanoSlots[1] = 2; - //response->PCLoadData2CL.aNanoSlots[2] = 3; + //response.PCLoadData2CL.aNanoSlots[0] = 1; + //response.PCLoadData2CL.aNanoSlots[1] = 2; + //response.PCLoadData2CL.aNanoSlots[2] = 3; - response->PCLoadData2CL.aQuestFlag[0] = -1; + response.PCLoadData2CL.aQuestFlag[0] = -1; - plr.iID = response->iID; + plr.iID = response.iID; plr.SerialKey = enter->iEnterSerialKey; - plr.HP = response->PCLoadData2CL.iHP; + plr.HP = response.PCLoadData2CL.iHP; - motd->iType = 1; - U8toU16(settings::MOTDSTRING, (char16_t*)motd->szSystemMsg); + motd.iType = 1; + U8toU16(settings::MOTDSTRING, (char16_t*)motd.szSystemMsg); - sock->setEKey(CNSocketEncryption::createNewKey(response->uiSvrTime, response->iID + 1, response->PCLoadData2CL.iFusionMatter + 1)); + sock->setEKey(CNSocketEncryption::createNewKey(response.uiSvrTime, response.iID + 1, response.PCLoadData2CL.iFusionMatter + 1)); sock->setFEKey(plr.FEKey); + sock->setActiveKey(SOCKETKEY_FE); // send all packets using the FE key from now on + + sock->sendPacket((void*)&response, P_FE2CL_REP_PC_ENTER_SUCC, sizeof(sP_FE2CL_REP_PC_ENTER_SUCC)); - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_ENTER_SUCC, sizeof(sP_FE2CL_REP_PC_ENTER_SUCC), sock->getFEKey())); // transmit MOTD after entering the game, so the client hopefully changes modes on time - sock->sendPacket(new CNPacketData((void*)motd, P_FE2CL_PC_MOTD_LOGIN, sizeof(sP_FE2CL_PC_MOTD_LOGIN), sock->getFEKey())); + sock->sendPacket((void*)&motd, P_FE2CL_PC_MOTD_LOGIN, sizeof(sP_FE2CL_PC_MOTD_LOGIN)); addPlayer(sock, plr); } @@ -243,16 +229,16 @@ void PlayerManager::loadPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_LOADING_COMPLETE* complete = (sP_CL2FE_REQ_PC_LOADING_COMPLETE*)data->buf; - sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC* response = (sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC)); + sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC response; DEBUGLOG( std::cout << "P_CL2FE_REQ_PC_LOADING_COMPLETE:" << std::endl; std::cout << "\tPC_ID: " << complete->iPC_ID << std::endl; ) - response->iPC_ID = complete->iPC_ID; + response.iPC_ID = complete->iPC_ID; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&response, P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC)); } void PlayerManager::movePlayer(CNSocket* sock, CNPacketData* data) { @@ -265,25 +251,25 @@ void PlayerManager::movePlayer(CNSocket* sock, CNPacketData* data) { players[sock].plr.angle = moveData->iAngle; uint64_t tm = getTime(); + sP_FE2CL_PC_MOVE moveResponse; + + moveResponse.iID = players[sock].plr.iID; + moveResponse.cKeyValue = moveData->cKeyValue; + + moveResponse.iX = moveData->iX; + moveResponse.iY = moveData->iY; + moveResponse.iZ = moveData->iZ; + moveResponse.iAngle = moveData->iAngle; + moveResponse.fVX = moveData->fVX; + moveResponse.fVY = moveData->fVY; + moveResponse.fVZ = moveData->fVZ; + + moveResponse.iSpeed = moveData->iSpeed; + moveResponse.iCliTime = moveData->iCliTime; // maybe don't send this??? seems unneeded... + moveResponse.iSvrTime = tm; + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_MOVE* moveResponse = (sP_FE2CL_PC_MOVE*)xmalloc(sizeof(sP_FE2CL_PC_MOVE)); - - moveResponse->iID = players[sock].plr.iID; - moveResponse->cKeyValue = moveData->cKeyValue; - - moveResponse->iX = moveData->iX; - moveResponse->iY = moveData->iY; - moveResponse->iZ = moveData->iZ; - moveResponse->iAngle = moveData->iAngle; - moveResponse->fVX = moveData->fVX; - moveResponse->fVY = moveData->fVY; - moveResponse->fVZ = moveData->fVZ; - - moveResponse->iSpeed = moveData->iSpeed; - moveResponse->iCliTime = moveData->iCliTime; // maybe don't send this??? seems unneeded... - moveResponse->iSvrTime = tm; - - otherSock->sendPacket(new CNPacketData((void*)moveResponse, P_FE2CL_PC_MOVE, sizeof(sP_FE2CL_PC_MOVE), otherSock->getFEKey())); + otherSock->sendPacket((void*)&moveResponse, P_FE2CL_PC_MOVE, sizeof(sP_FE2CL_PC_MOVE)); } } @@ -296,19 +282,19 @@ void PlayerManager::stopPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); + sP_FE2CL_PC_STOP stopResponse; + + stopResponse.iID = players[sock].plr.iID; + + stopResponse.iX = stopData->iX; + stopResponse.iY = stopData->iY; + stopResponse.iZ = stopData->iZ; + + stopResponse.iCliTime = stopData->iCliTime; // maybe don't send this??? seems unneeded... + stopResponse.iSvrTime = tm; + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_STOP* stopResponse = (sP_FE2CL_PC_STOP*)xmalloc(sizeof(sP_FE2CL_PC_STOP)); - - stopResponse->iID = players[sock].plr.iID; - - stopResponse->iX = stopData->iX; - stopResponse->iY = stopData->iY; - stopResponse->iZ = stopData->iZ; - - stopResponse->iCliTime = stopData->iCliTime; // maybe don't send this??? seems unneeded... - stopResponse->iSvrTime = tm; - - otherSock->sendPacket(new CNPacketData((void*)stopResponse, P_FE2CL_PC_STOP, sizeof(sP_FE2CL_PC_STOP), otherSock->getFEKey())); + otherSock->sendPacket((void*)&stopResponse, P_FE2CL_PC_STOP, sizeof(sP_FE2CL_PC_STOP)); } } @@ -321,25 +307,25 @@ void PlayerManager::jumpPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); + sP_FE2CL_PC_JUMP jumpResponse; + + jumpResponse.iID = players[sock].plr.iID; + jumpResponse.cKeyValue = jumpData->cKeyValue; + + jumpResponse.iX = jumpData->iX; + jumpResponse.iY = jumpData->iY; + jumpResponse.iZ = jumpData->iZ; + jumpResponse.iAngle = jumpData->iAngle; + jumpResponse.iVX = jumpData->iVX; + jumpResponse.iVY = jumpData->iVY; + jumpResponse.iVZ = jumpData->iVZ; + + jumpResponse.iSpeed = jumpData->iSpeed; + jumpResponse.iCliTime = jumpData->iCliTime; // maybe don't send this??? seems unneeded... + jumpResponse.iSvrTime = tm; + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_JUMP* jumpResponse = (sP_FE2CL_PC_JUMP*)xmalloc(sizeof(sP_FE2CL_PC_JUMP)); - - jumpResponse->iID = players[sock].plr.iID; - jumpResponse->cKeyValue = jumpData->cKeyValue; - - jumpResponse->iX = jumpData->iX; - jumpResponse->iY = jumpData->iY; - jumpResponse->iZ = jumpData->iZ; - jumpResponse->iAngle = jumpData->iAngle; - jumpResponse->iVX = jumpData->iVX; - jumpResponse->iVY = jumpData->iVY; - jumpResponse->iVZ = jumpData->iVZ; - - jumpResponse->iSpeed = jumpData->iSpeed; - jumpResponse->iCliTime = jumpData->iCliTime; // maybe don't send this??? seems unneeded... - jumpResponse->iSvrTime = tm; - - otherSock->sendPacket(new CNPacketData((void*)jumpResponse, P_FE2CL_PC_JUMP, sizeof(sP_FE2CL_PC_JUMP), otherSock->getFEKey())); + otherSock->sendPacket((void*)&jumpResponse, P_FE2CL_PC_JUMP, sizeof(sP_FE2CL_PC_JUMP)); } } @@ -352,23 +338,23 @@ void PlayerManager::jumppadPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); + sP_FE2CL_PC_JUMPPAD jumppadResponse; + + jumppadResponse.iPC_ID = players[sock].plr.iID; + jumppadResponse.cKeyValue = jumppadData->cKeyValue; + + jumppadResponse.iX = jumppadData->iX; + jumppadResponse.iY = jumppadData->iY; + jumppadResponse.iZ = jumppadData->iZ; + jumppadResponse.iVX = jumppadData->iVX; + jumppadResponse.iVY = jumppadData->iVY; + jumppadResponse.iVZ = jumppadData->iVZ; + + jumppadResponse.iCliTime = jumppadData->iCliTime; + jumppadResponse.iSvrTime = tm; + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_JUMPPAD* jumppadResponse = (sP_FE2CL_PC_JUMPPAD*)xmalloc(sizeof(sP_FE2CL_PC_JUMPPAD)); - - jumppadResponse->iPC_ID = players[sock].plr.iID; - jumppadResponse->cKeyValue = jumppadData->cKeyValue; - - jumppadResponse->iX = jumppadData->iX; - jumppadResponse->iY = jumppadData->iY; - jumppadResponse->iZ = jumppadData->iZ; - jumppadResponse->iVX = jumppadData->iVX; - jumppadResponse->iVY = jumppadData->iVY; - jumppadResponse->iVZ = jumppadData->iVZ; - - jumppadResponse->iCliTime = jumppadData->iCliTime; - jumppadResponse->iSvrTime = tm; - - otherSock->sendPacket(new CNPacketData((void*)jumppadResponse, P_FE2CL_PC_JUMPPAD, sizeof(sP_FE2CL_PC_JUMPPAD), otherSock->getFEKey())); + otherSock->sendPacket((void*)&jumppadResponse, P_FE2CL_PC_JUMPPAD, sizeof(sP_FE2CL_PC_JUMPPAD)); } } @@ -381,24 +367,24 @@ void PlayerManager::launchPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); + sP_FE2CL_PC_LAUNCHER launchResponse; + + launchResponse.iPC_ID = players[sock].plr.iID; + + launchResponse.iX = launchData->iX; + launchResponse.iY = launchData->iY; + launchResponse.iZ = launchData->iZ; + launchResponse.iVX = launchData->iVX; + launchResponse.iVY = launchData->iVY; + launchResponse.iVZ = launchData->iVZ; + launchResponse.iSpeed = launchData->iSpeed; + launchResponse.iAngle = launchData->iAngle; + + launchResponse.iCliTime = launchData->iCliTime; + launchResponse.iSvrTime = tm; + for (CNSocket* otherSock : players[sock].viewable) { - sP_FE2CL_PC_LAUNCHER* launchResponse = (sP_FE2CL_PC_LAUNCHER*)xmalloc(sizeof(sP_FE2CL_PC_LAUNCHER)); - - launchResponse->iPC_ID = players[sock].plr.iID; - - launchResponse->iX = launchData->iX; - launchResponse->iY = launchData->iY; - launchResponse->iZ = launchData->iZ; - launchResponse->iVX = launchData->iVX; - launchResponse->iVY = launchData->iVY; - launchResponse->iVZ = launchData->iVZ; - launchResponse->iSpeed = launchData->iSpeed; - launchResponse->iAngle = launchData->iAngle; - - launchResponse->iCliTime = launchData->iCliTime; - launchResponse->iSvrTime = tm; - - otherSock->sendPacket(new CNPacketData((void*)launchResponse, P_FE2CL_PC_LAUNCHER, sizeof(sP_FE2CL_PC_LAUNCHER), otherSock->getFEKey())); + otherSock->sendPacket((void*)&launchResponse, P_FE2CL_PC_LAUNCHER, sizeof(sP_FE2CL_PC_LAUNCHER)); } } @@ -411,32 +397,31 @@ void PlayerManager::ziplinePlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); + sP_FE2CL_PC_ZIPLINE ziplineResponse; + + ziplineResponse.iPC_ID = players[sock].plr.iID; + ziplineResponse.iCliTime = ziplineData->iCliTime; + ziplineResponse.iSvrTime = tm; + ziplineResponse.iX = ziplineData->iX; + ziplineResponse.iY = ziplineData->iY; + ziplineResponse.iZ = ziplineData->iZ; + ziplineResponse.fVX = ziplineData->fVX; + ziplineResponse.fVY = ziplineData->fVY; + ziplineResponse.fVZ = ziplineData->fVZ; + ziplineResponse.fMovDistance = ziplineData->fMovDistance; + ziplineResponse.fMaxDistance = ziplineData->fMaxDistance; + ziplineResponse.fDummy = ziplineData->fDummy; //wtf is this for? + ziplineResponse.iStX = ziplineData->iStX; + ziplineResponse.iStY = ziplineData->iStY; + ziplineResponse.iStZ = ziplineData->iStZ; + ziplineResponse.bDown = ziplineData->bDown; + ziplineResponse.iSpeed = ziplineData->iSpeed; + ziplineResponse.iAngle = ziplineData->iAngle; + ziplineResponse.iRollMax = ziplineData->iRollMax; + ziplineResponse.iRoll = ziplineData->iRoll; + for (CNSocket* otherSock : players[sock].viewable) { - - sP_FE2CL_PC_ZIPLINE* ziplineResponse = (sP_FE2CL_PC_ZIPLINE*)xmalloc(sizeof(sP_FE2CL_PC_ZIPLINE)); - - ziplineResponse->iPC_ID = players[sock].plr.iID; - ziplineResponse->iCliTime = ziplineData->iCliTime; - ziplineResponse->iSvrTime = tm; - ziplineResponse->iX = ziplineData->iX; - ziplineResponse->iY = ziplineData->iY; - ziplineResponse->iZ = ziplineData->iZ; - ziplineResponse->fVX = ziplineData->fVX; - ziplineResponse->fVY = ziplineData->fVY; - ziplineResponse->fVZ = ziplineData->fVZ; - ziplineResponse->fMovDistance = ziplineData->fMovDistance; - ziplineResponse->fMaxDistance = ziplineData->fMaxDistance; - ziplineResponse->fDummy = ziplineData->fDummy; //wtf is this for? - ziplineResponse->iStX = ziplineData->iStX; - ziplineResponse->iStY = ziplineData->iStY; - ziplineResponse->iStZ = ziplineData->iStZ; - ziplineResponse->bDown = ziplineData->bDown; - ziplineResponse->iSpeed = ziplineData->iSpeed; - ziplineResponse->iAngle = ziplineData->iAngle; - ziplineResponse->iRollMax = ziplineData->iRollMax; - ziplineResponse->iRoll = ziplineData->iRoll; - - otherSock->sendPacket(new CNPacketData((void*)ziplineResponse, P_FE2CL_PC_ZIPLINE, sizeof(sP_FE2CL_PC_ZIPLINE), otherSock->getFEKey())); + otherSock->sendPacket((void*)&ziplineResponse, P_FE2CL_PC_ZIPLINE, sizeof(sP_FE2CL_PC_ZIPLINE)); } } @@ -449,29 +434,28 @@ void PlayerManager::movePlatformPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); + sP_FE2CL_PC_MOVEPLATFORM platResponse; + + platResponse.iPC_ID = players[sock].plr.iID; + platResponse.iCliTime = platformData->iCliTime; + platResponse.iSvrTime = tm; + platResponse.iX = platformData->iX; + platResponse.iY = platformData->iY; + platResponse.iZ = platformData->iZ; + platResponse.iAngle = platformData->iAngle; + platResponse.fVX = platformData->fVX; + platResponse.fVY = platformData->fVY; + platResponse.fVZ = platformData->fVZ; + platResponse.iLcX = platformData->iLcX; + platResponse.iLcY = platformData->iLcY; + platResponse.iLcZ = platformData->iLcZ; + platResponse.iSpeed = platformData->iSpeed; + platResponse.bDown = platformData->bDown; + platResponse.cKeyValue = platformData->cKeyValue; + platResponse.iPlatformID = platformData->iPlatformID; + for (CNSocket* otherSock : players[sock].viewable) { - - sP_FE2CL_PC_MOVEPLATFORM* platResponse = (sP_FE2CL_PC_MOVEPLATFORM*)xmalloc(sizeof(sP_FE2CL_PC_MOVEPLATFORM)); - - platResponse->iPC_ID = players[sock].plr.iID; - platResponse->iCliTime = platformData->iCliTime; - platResponse->iSvrTime = tm; - platResponse->iX = platformData->iX; - platResponse->iY = platformData->iY; - platResponse->iZ = platformData->iZ; - platResponse->iAngle = platformData->iAngle; - platResponse->fVX = platformData->fVX; - platResponse->fVY = platformData->fVY; - platResponse->fVZ = platformData->fVZ; - platResponse->iLcX = platformData->iLcX; - platResponse->iLcY = platformData->iLcY; - platResponse->iLcZ = platformData->iLcZ; - platResponse->iSpeed = platformData->iSpeed; - platResponse->bDown = platformData->bDown; - platResponse->cKeyValue = platformData->cKeyValue; - platResponse->iPlatformID = platformData->iPlatformID; - - otherSock->sendPacket(new CNPacketData((void*)platResponse, P_FE2CL_PC_MOVEPLATFORM, sizeof(sP_FE2CL_PC_MOVEPLATFORM), otherSock->getFEKey())); + otherSock->sendPacket((void*)&platResponse, P_FE2CL_PC_MOVEPLATFORM, sizeof(sP_FE2CL_PC_MOVEPLATFORM)); } } @@ -484,25 +468,24 @@ void PlayerManager::moveSlopePlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); + sP_FE2CL_PC_SLOPE slopeResponse; + + slopeResponse.iPC_ID = players[sock].plr.iID; + slopeResponse.iCliTime = slopeData->iCliTime; + slopeResponse.iSvrTime = tm; + slopeResponse.iX = slopeData->iX; + slopeResponse.iY = slopeData->iY; + slopeResponse.iZ = slopeData->iZ; + slopeResponse.iAngle = slopeData->iAngle; + slopeResponse.fVX = slopeData->fVX; + slopeResponse.fVY = slopeData->fVY; + slopeResponse.fVZ = slopeData->fVZ; + slopeResponse.iSpeed = slopeData->iSpeed; + slopeResponse.cKeyValue = slopeData->cKeyValue; + slopeResponse.iSlopeID = slopeData->iSlopeID; + for (CNSocket* otherSock : players[sock].viewable) { - - sP_FE2CL_PC_SLOPE* slopeResponse = (sP_FE2CL_PC_SLOPE*)xmalloc(sizeof(sP_FE2CL_PC_SLOPE)); - - slopeResponse->iPC_ID = players[sock].plr.iID; - slopeResponse->iCliTime = slopeData->iCliTime; - slopeResponse->iSvrTime = tm; - slopeResponse->iX = slopeData->iX; - slopeResponse->iY = slopeData->iY; - slopeResponse->iZ = slopeData->iZ; - slopeResponse->iAngle = slopeData->iAngle; - slopeResponse->fVX = slopeData->fVX; - slopeResponse->fVY = slopeData->fVY; - slopeResponse->fVZ = slopeData->fVZ; - slopeResponse->iSpeed = slopeData->iSpeed; - slopeResponse->cKeyValue = slopeData->cKeyValue; - slopeResponse->iSlopeID = slopeData->iSlopeID; - - otherSock->sendPacket(new CNPacketData((void*)slopeResponse, P_FE2CL_PC_SLOPE, sizeof(sP_FE2CL_PC_SLOPE), otherSock->getFEKey())); + otherSock->sendPacket((void*)&slopeResponse, P_FE2CL_PC_SLOPE, sizeof(sP_FE2CL_PC_SLOPE)); } } @@ -511,7 +494,7 @@ void PlayerManager::gotoPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_GOTO* gotoData = (sP_CL2FE_REQ_PC_GOTO*)data->buf; - sP_FE2CL_REP_PC_GOTO_SUCC* response = (sP_FE2CL_REP_PC_GOTO_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_GOTO_SUCC)); + sP_FE2CL_REP_PC_GOTO_SUCC response; DEBUGLOG( std::cout << "P_CL2FE_REQ_PC_GOTO:" << std::endl; @@ -520,11 +503,11 @@ void PlayerManager::gotoPlayer(CNSocket* sock, CNPacketData* data) { std::cout << "\tZ: " << gotoData->iToZ << std::endl; ) - response->iX = gotoData->iToX; - response->iY = gotoData->iToY; - response->iZ = gotoData->iToZ; + response.iX = gotoData->iToX; + response.iY = gotoData->iToY; + response.iZ = gotoData->iToZ; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_GOTO_SUCC, sizeof(sP_FE2CL_REP_PC_GOTO_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&response, P_FE2CL_REP_PC_GOTO_SUCC, sizeof(sP_FE2CL_REP_PC_GOTO_SUCC)); } void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) { @@ -532,7 +515,7 @@ void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_GM_REQ_PC_SET_VALUE* setData = (sP_CL2FE_GM_REQ_PC_SET_VALUE*)data->buf; - sP_FE2CL_GM_REP_PC_SET_VALUE* response = (sP_FE2CL_GM_REP_PC_SET_VALUE*)xmalloc(sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE)); + sP_FE2CL_GM_REP_PC_SET_VALUE response; DEBUGLOG( std::cout << "P_CL2FE_GM_REQ_PC_SET_VALUE:" << std::endl; @@ -541,11 +524,11 @@ void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) { std::cout << "\tSetValue: " << setData->iSetValue << std::endl; ) - response->iPC_ID = setData->iPC_ID; - response->iSetValue = setData->iSetValue; - response->iSetValueType = setData->iSetValueType; + response.iPC_ID = setData->iPC_ID; + response.iSetValue = setData->iSetValue; + response.iSetValueType = setData->iSetValueType; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_GM_REP_PC_SET_VALUE, sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE), sock->getFEKey())); + sock->sendPacket((void*)&response, P_FE2CL_GM_REP_PC_SET_VALUE, sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE)); } void PlayerManager::heartbeatPlayer(CNSocket* sock, CNPacketData* data) { @@ -557,12 +540,12 @@ void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { return; sP_CL2FE_REQ_PC_EXIT* exitData = (sP_CL2FE_REQ_PC_EXIT*)data->buf; - sP_FE2CL_REP_PC_EXIT_SUCC* response = (sP_FE2CL_REP_PC_EXIT_SUCC*)xmalloc(sizeof(sP_FE2CL_REP_PC_EXIT_SUCC)); + sP_FE2CL_REP_PC_EXIT_SUCC response; - response->iID = exitData->iID; - response->iExitCode = 1; + response.iID = exitData->iID; + response.iExitCode = 1; - sock->sendPacket(new CNPacketData((void*)response, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC), sock->getFEKey())); + sock->sendPacket((void*)&response, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC)); } void PlayerManager::updatePlayer(CNSocket* key, Player plr) { From 88953541ef169e8c57de07405a8343d62cc4df8a Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 19:26:18 -0500 Subject: [PATCH 17/22] added INITSTRUCT to zero-out data --- config.ini | 4 ++-- src/CNLoginServer.cpp | 12 ++++++------ src/CNShardServer.cpp | 2 +- src/CNStructs.hpp | 4 ++++ src/ChatManager.cpp | 6 +++--- src/ItemManager.cpp | 8 ++++---- src/NPCManager.cpp | 4 ++-- src/NanoManager.cpp | 12 ++++++------ src/PlayerManager.cpp | 33 ++++++++++++++++----------------- 9 files changed, 44 insertions(+), 41 deletions(-) diff --git a/config.ini b/config.ini index 5586a25..d55e3a8 100644 --- a/config.ini +++ b/config.ini @@ -1,5 +1,5 @@ # should the server print every packet it receives? -verbose=false +verbose=true # Login Server configuration [login] @@ -13,7 +13,7 @@ randomcharacters=true [shard] port=8002 # you'll want to change this one -ip=127.0.0.1 +ip=192.168.1.183 # distance at which other players and NPCs become visible view=20000 # little message players see when they enter the game diff --git a/src/CNLoginServer.cpp b/src/CNLoginServer.cpp index f175e30..c9edcbe 100644 --- a/src/CNLoginServer.cpp +++ b/src/CNLoginServer.cpp @@ -26,7 +26,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2LS_REQ_LOGIN* login = (sP_CL2LS_REQ_LOGIN*)data->buf; - sP_LS2CL_REP_LOGIN_SUCC resp; + INITSTRUCT(sP_LS2CL_REP_LOGIN_SUCC, resp); uint64_t cachedKey = sock->getEKey(); // so we can still send the resp packet with the correct key int charCount = 2; // send 4 randomly generated characters for now @@ -131,7 +131,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { // naughty words allowed!!!!!!!! (also for some reason, the client will always show 'Player 0' if you manually type a name. It will show up for other connected players though) sP_CL2LS_REQ_CHECK_CHAR_NAME* nameCheck = (sP_CL2LS_REQ_CHECK_CHAR_NAME*)data->buf; - sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC resp; + INITSTRUCT(sP_LS2CL_REP_CHECK_CHAR_NAME_SUCC, resp); DEBUGLOG( std::cout << "P_CL2LS_REQ_CHECK_CHAR_NAME:" << std::endl; @@ -150,7 +150,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { return; sP_CL2LS_REQ_SAVE_CHAR_NAME* save = (sP_CL2LS_REQ_SAVE_CHAR_NAME*)data->buf; - sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC resp; + INITSTRUCT(sP_LS2CL_REP_SAVE_CHAR_NAME_SUCC, resp); DEBUGLOG( std::cout << "P_CL2LS_REQ_SAVE_CHAR_NAME:" << std::endl; @@ -172,7 +172,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { return; sP_CL2LS_REQ_CHAR_CREATE* character = (sP_CL2LS_REQ_CHAR_CREATE*)data->buf; - sP_LS2CL_REP_CHAR_CREATE_SUCC resp; + INITSTRUCT(sP_LS2CL_REP_CHAR_CREATE_SUCC, resp); DEBUGLOG( std::cout << "P_CL2LS_REQ_CHAR_CREATE:" << std::endl; @@ -240,7 +240,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { // character selected sP_CL2LS_REQ_CHAR_SELECT* chararacter = (sP_CL2LS_REQ_CHAR_SELECT*)data->buf; - sP_LS2CL_REP_CHAR_SELECT_SUCC resp; + INITSTRUCT(sP_LS2CL_REP_CHAR_SELECT_SUCC, resp); DEBUGLOG( std::cout << "P_CL2LS_REQ_CHAR_SELECT:" << std::endl; @@ -258,7 +258,7 @@ void CNLoginServer::handlePacket(CNSocket* sock, CNPacketData* data) { // tell client to connect to the shard server sP_CL2LS_REQ_SHARD_SELECT* shard = (sP_CL2LS_REQ_SHARD_SELECT*)data->buf; - sP_LS2CL_REP_SHARD_SELECT_SUCC resp; + INITSTRUCT(sP_LS2CL_REP_SHARD_SELECT_SUCC, resp); DEBUGLOG( std::cout << "P_CL2LS_REQ_SHARD_SELECT:" << std::endl; diff --git a/src/CNShardServer.cpp b/src/CNShardServer.cpp index de30956..9a202ba 100644 --- a/src/CNShardServer.cpp +++ b/src/CNShardServer.cpp @@ -52,7 +52,7 @@ void CNShardServer::onTimer() { } // passed the heartbeat, send another - sP_FE2CL_REQ_LIVE_CHECK data; + INITSTRUCT(sP_FE2CL_REQ_LIVE_CHECK, data); pair.first->sendPacket((void*)&data, P_FE2CL_REQ_LIVE_CHECK, sizeof(sP_FE2CL_REQ_LIVE_CHECK)); } } diff --git a/src/CNStructs.hpp b/src/CNStructs.hpp index 6adebec..0b7de0b 100644 --- a/src/CNStructs.hpp +++ b/src/CNStructs.hpp @@ -25,6 +25,10 @@ #include #include +// yes this is ugly, but this is needed to zero out the memory so we don't have random stackdata in our structs. +#define INITSTRUCT(T, x) T x; \ + memset(&x, 0, sizeof(T)); + // TODO: rewrite U16toU8 & U8toU16 to not use codecvt std::string U16toU8(char16_t* src); diff --git a/src/ChatManager.cpp b/src/ChatManager.cpp index e9b5318..e3f4bbc 100644 --- a/src/ChatManager.cpp +++ b/src/ChatManager.cpp @@ -16,7 +16,7 @@ void ChatManager::chatHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // send to client - sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, resp); memcpy(resp.szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); resp.iPC_ID = plr.plr.iID; resp.iEmoteCode = chat->iEmoteCode; @@ -35,7 +35,7 @@ void ChatManager::menuChatHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // send to client - sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, resp); memcpy(resp.szFreeChat, chat->szFreeChat, sizeof(chat->szFreeChat)); resp.iPC_ID = plr.plr.iID; resp.iEmoteCode = chat->iEmoteCode; @@ -56,7 +56,7 @@ void ChatManager::emoteHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // send to client - sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT resp; + INITSTRUCT(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, resp); resp.iEmoteCode = emote->iEmoteCode; resp.iID_From = plr.plr.iID; sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT)); diff --git a/src/ItemManager.cpp b/src/ItemManager.cpp index 47c6e53..a293aa6 100644 --- a/src/ItemManager.cpp +++ b/src/ItemManager.cpp @@ -15,7 +15,7 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_ITEM_MOVE* itemmove = (sP_CL2FE_REQ_ITEM_MOVE*)data->buf; - sP_FE2CL_PC_ITEM_MOVE_SUCC resp; + INITSTRUCT(sP_FE2CL_PC_ITEM_MOVE_SUCC, resp); PlayerView& plr = PlayerManager::players[sock]; sItemBase fromItem; @@ -46,7 +46,7 @@ void ItemManager::itemMoveHandler(CNSocket* sock, CNPacketData* data) { } if (itemmove->eFrom == 0 || itemmove->eTo == 0) { - sP_FE2CL_PC_EQUIP_CHANGE equipChange; + INITSTRUCT(sP_FE2CL_PC_EQUIP_CHANGE, equipChange); equipChange.iPC_ID = plr.plr.iID; if (itemmove->eFrom == 0) { @@ -78,7 +78,7 @@ void ItemManager::itemDeleteHandler(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_ITEM_DELETE* itemdel = (sP_CL2FE_REQ_PC_ITEM_DELETE*)data->buf; - sP_FE2CL_REP_PC_ITEM_DELETE_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC, resp); PlayerView& plr = PlayerManager::players[sock]; @@ -110,7 +110,7 @@ void ItemManager::itemGMGiveHandler(CNSocket* sock, CNPacketData* data) { // Quest item, not a real item, handle this later, stubbed for now // sock->sendPacket(new CNPacketData((void*)resp, P_FE2CL_REP_PC_GIVE_ITEM_FAIL, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_FAIL), sock->getFEKey())); } else if (itemreq->eIL == 1) { - sP_FE2CL_REP_PC_GIVE_ITEM_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC, resp); resp.eIL = itemreq->eIL; resp.iSlotNum = itemreq->iSlotNum; diff --git a/src/NPCManager.cpp b/src/NPCManager.cpp index 094b58f..0f23812 100644 --- a/src/NPCManager.cpp +++ b/src/NPCManager.cpp @@ -49,7 +49,7 @@ void NPCManager::updatePlayerNPCS(CNSocket* sock, PlayerView& view) { } } - sP_FE2CL_NPC_EXIT exitData; + INITSTRUCT(sP_FE2CL_NPC_EXIT, exitData); std::list::iterator i = view.viewableNPCs.begin(); while (i != view.viewableNPCs.end()) { int32_t id = *i; @@ -67,7 +67,7 @@ void NPCManager::updatePlayerNPCS(CNSocket* sock, PlayerView& view) { ++i; } - sP_FE2CL_NPC_ENTER enterData; + INITSTRUCT(sP_FE2CL_NPC_ENTER, enterData); for (int32_t id : yesView) { if (std::find(view.viewableNPCs.begin(), view.viewableNPCs.end(), id) == view.viewableNPCs.end()) { // needs to be added to viewableNPCs! send NPC_ENTER diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index c293a7f..0b7ef25 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -17,7 +17,7 @@ void NanoManager::nanoEquipHandler(CNSocket* sock, CNPacketData* data) { return; // malformed packet sP_CL2FE_REQ_NANO_EQUIP* nano = (sP_CL2FE_REQ_NANO_EQUIP*)data->buf; - sP_FE2CL_REP_NANO_EQUIP_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_NANO_EQUIP_SUCC, resp); resp.iNanoID = nano->iNanoID; resp.iNanoSlotNum = nano->iNanoSlotNum; @@ -30,7 +30,7 @@ void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) { return; // malformed packet sP_CL2FE_REQ_NANO_UNEQUIP* nano = (sP_CL2FE_REQ_NANO_UNEQUIP*)data->buf; - sP_FE2CL_REP_NANO_UNEQUIP_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_NANO_UNEQUIP_SUCC, resp); resp.iNanoSlotNum = nano->iNanoSlotNum; @@ -61,7 +61,7 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // Send to client - sP_FE2CL_REP_NANO_ACTIVE_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_NANO_ACTIVE_SUCC, resp); resp.iActiveNanoSlotNum = nano->iNanoSlotNum; sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC)); @@ -78,7 +78,7 @@ void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { PlayerView plr = PlayerManager::players[sock]; // Send to client - sP_FE2CL_NANO_SKILL_USE_SUCC resp; + INITSTRUCT(sP_FE2CL_NANO_SKILL_USE_SUCC, resp); resp.iArg1 = skill->iArg1; resp.iArg2 = skill->iArg2; resp.iArg3 = skill->iArg3; @@ -107,7 +107,7 @@ void NanoManager::addNano(CNSocket* sock, int16_t nanoId, int16_t slot) { Player plr = PlayerManager::getPlayer(sock); // Send to client - sP_FE2CL_REP_PC_NANO_CREATE_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_PC_NANO_CREATE_SUCC, resp); resp.Nano.iID = nanoId; resp.Nano.iStamina = 150; resp.iQuestItemSlotNum = slot; @@ -127,7 +127,7 @@ void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) plr.Nanos[nanoId] = nano; // Send to client - sP_FE2CL_REP_NANO_TUNE_SUCC resp; + INITSTRUCT(sP_FE2CL_REP_NANO_TUNE_SUCC, resp); resp.iNanoID = nanoId; resp.iSkillID = skillId; diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index c246d19..b8f8b80 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -88,8 +88,7 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { } } - sP_FE2CL_PC_EXIT exitPacket; - + INITSTRUCT(sP_FE2CL_PC_EXIT, exitPacket); std::list::iterator i = players[sock].viewable.begin(); while (i != players[sock].viewable.end()) { CNSocket* otherSock = *i; @@ -110,7 +109,7 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { ++i; } - sP_FE2CL_PC_NEW newPlayer; + INITSTRUCT(sP_FE2CL_PC_NEW, newPlayer); for (CNSocket* otherSock : yesView) { if (std::find(players[sock].viewable.begin(), players[sock].viewable.end(), otherSock) == players[sock].viewable.end()) { // this needs to be added to the viewable players, send PC_ENTER @@ -155,8 +154,8 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_ENTER* enter = (sP_CL2FE_REQ_PC_ENTER*)data->buf; - sP_FE2CL_REP_PC_ENTER_SUCC response; - sP_FE2CL_PC_MOTD_LOGIN motd; + INITSTRUCT(sP_FE2CL_REP_PC_ENTER_SUCC, response); + INITSTRUCT(sP_FE2CL_PC_MOTD_LOGIN, motd); // TODO: check if serialkey exists, if it doesn't send sP_FE2CL_REP_PC_ENTER_FAIL Player plr = CNSharedData::getPlayer(enter->iEnterSerialKey); @@ -229,7 +228,7 @@ void PlayerManager::loadPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_LOADING_COMPLETE* complete = (sP_CL2FE_REQ_PC_LOADING_COMPLETE*)data->buf; - sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC response; + INITSTRUCT(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, response); DEBUGLOG( std::cout << "P_CL2FE_REQ_PC_LOADING_COMPLETE:" << std::endl; @@ -251,7 +250,7 @@ void PlayerManager::movePlayer(CNSocket* sock, CNPacketData* data) { players[sock].plr.angle = moveData->iAngle; uint64_t tm = getTime(); - sP_FE2CL_PC_MOVE moveResponse; + INITSTRUCT(sP_FE2CL_PC_MOVE, moveResponse); moveResponse.iID = players[sock].plr.iID; moveResponse.cKeyValue = moveData->cKeyValue; @@ -282,7 +281,7 @@ void PlayerManager::stopPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); - sP_FE2CL_PC_STOP stopResponse; + INITSTRUCT(sP_FE2CL_PC_STOP, stopResponse); stopResponse.iID = players[sock].plr.iID; @@ -307,7 +306,7 @@ void PlayerManager::jumpPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); - sP_FE2CL_PC_JUMP jumpResponse; + INITSTRUCT(sP_FE2CL_PC_JUMP, jumpResponse); jumpResponse.iID = players[sock].plr.iID; jumpResponse.cKeyValue = jumpData->cKeyValue; @@ -338,7 +337,7 @@ void PlayerManager::jumppadPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); - sP_FE2CL_PC_JUMPPAD jumppadResponse; + INITSTRUCT(sP_FE2CL_PC_JUMPPAD, jumppadResponse); jumppadResponse.iPC_ID = players[sock].plr.iID; jumppadResponse.cKeyValue = jumppadData->cKeyValue; @@ -367,7 +366,7 @@ void PlayerManager::launchPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); - sP_FE2CL_PC_LAUNCHER launchResponse; + INITSTRUCT(sP_FE2CL_PC_LAUNCHER, launchResponse); launchResponse.iPC_ID = players[sock].plr.iID; @@ -397,7 +396,7 @@ void PlayerManager::ziplinePlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); - sP_FE2CL_PC_ZIPLINE ziplineResponse; + INITSTRUCT(sP_FE2CL_PC_ZIPLINE, ziplineResponse); ziplineResponse.iPC_ID = players[sock].plr.iID; ziplineResponse.iCliTime = ziplineData->iCliTime; @@ -434,7 +433,7 @@ void PlayerManager::movePlatformPlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); - sP_FE2CL_PC_MOVEPLATFORM platResponse; + INITSTRUCT(sP_FE2CL_PC_MOVEPLATFORM, platResponse); platResponse.iPC_ID = players[sock].plr.iID; platResponse.iCliTime = platformData->iCliTime; @@ -468,7 +467,7 @@ void PlayerManager::moveSlopePlayer(CNSocket* sock, CNPacketData* data) { uint64_t tm = getTime(); - sP_FE2CL_PC_SLOPE slopeResponse; + INITSTRUCT(sP_FE2CL_PC_SLOPE, slopeResponse); slopeResponse.iPC_ID = players[sock].plr.iID; slopeResponse.iCliTime = slopeData->iCliTime; @@ -494,7 +493,7 @@ void PlayerManager::gotoPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_REQ_PC_GOTO* gotoData = (sP_CL2FE_REQ_PC_GOTO*)data->buf; - sP_FE2CL_REP_PC_GOTO_SUCC response; + INITSTRUCT(sP_FE2CL_REP_PC_GOTO_SUCC, response); DEBUGLOG( std::cout << "P_CL2FE_REQ_PC_GOTO:" << std::endl; @@ -515,7 +514,7 @@ void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) { return; // ignore the malformed packet sP_CL2FE_GM_REQ_PC_SET_VALUE* setData = (sP_CL2FE_GM_REQ_PC_SET_VALUE*)data->buf; - sP_FE2CL_GM_REP_PC_SET_VALUE response; + INITSTRUCT(sP_FE2CL_GM_REP_PC_SET_VALUE, response); DEBUGLOG( std::cout << "P_CL2FE_GM_REQ_PC_SET_VALUE:" << std::endl; @@ -540,7 +539,7 @@ void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { return; sP_CL2FE_REQ_PC_EXIT* exitData = (sP_CL2FE_REQ_PC_EXIT*)data->buf; - sP_FE2CL_REP_PC_EXIT_SUCC response; + INITSTRUCT(sP_FE2CL_REP_PC_EXIT_SUCC, response); response.iID = exitData->iID; response.iExitCode = 1; From c9bf3d1896e38821f6f75a219bfe5eefc8643d42 Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 19:27:08 -0500 Subject: [PATCH 18/22] restored default config.ini --- config.ini | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/config.ini b/config.ini index d55e3a8..5586a25 100644 --- a/config.ini +++ b/config.ini @@ -1,5 +1,5 @@ # should the server print every packet it receives? -verbose=true +verbose=false # Login Server configuration [login] @@ -13,7 +13,7 @@ randomcharacters=true [shard] port=8002 # you'll want to change this one -ip=192.168.1.183 +ip=127.0.0.1 # distance at which other players and NPCs become visible view=20000 # little message players see when they enter the game From 6129c0b4e28aaa0fef2ddaf77157c082a6729768 Mon Sep 17 00:00:00 2001 From: dongresource <69976329+dongresource@users.noreply.github.com> Date: Sun, 23 Aug 2020 02:52:54 +0200 Subject: [PATCH 19/22] Players can now see eachother's nanos. (#28) --- src/NanoManager.cpp | 35 +++++++++++++++++++++++++++++++---- src/Player.hpp | 6 ++++-- src/PlayerManager.cpp | 4 +++- 3 files changed, 38 insertions(+), 7 deletions(-) diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index 0b7ef25..a918c45 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -18,10 +18,15 @@ void NanoManager::nanoEquipHandler(CNSocket* sock, CNPacketData* data) { sP_CL2FE_REQ_NANO_EQUIP* nano = (sP_CL2FE_REQ_NANO_EQUIP*)data->buf; INITSTRUCT(sP_FE2CL_REP_NANO_EQUIP_SUCC, resp); + Player plr = PlayerManager::getPlayer(sock); resp.iNanoID = nano->iNanoID; resp.iNanoSlotNum = nano->iNanoSlotNum; + // Update player + plr.equippedNanos[nano->iNanoSlotNum] = nano->iNanoID; + PlayerManager::updatePlayer(sock, plr); + sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_EQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_EQUIP_SUCC)); } @@ -31,9 +36,14 @@ void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) { sP_CL2FE_REQ_NANO_UNEQUIP* nano = (sP_CL2FE_REQ_NANO_UNEQUIP*)data->buf; INITSTRUCT(sP_FE2CL_REP_NANO_UNEQUIP_SUCC, resp); + Player plr = PlayerManager::getPlayer(sock); resp.iNanoSlotNum = nano->iNanoSlotNum; + // update player + plr.equippedNanos[nano->iNanoSlotNum] = 0; + PlayerManager::updatePlayer(sock, plr); + sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_UNEQUIP_SUCC, sizeof(sP_FE2CL_REP_NANO_UNEQUIP_SUCC)); } @@ -57,16 +67,33 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_NANO_ACTIVE)) return; // malformed packet - sP_CL2FE_REQ_NANO_ACTIVE* nano = (sP_CL2FE_REQ_NANO_ACTIVE*)data->buf; + sP_CL2FE_REQ_NANO_ACTIVE* pkt = (sP_CL2FE_REQ_NANO_ACTIVE*)data->buf; PlayerView plr = PlayerManager::players[sock]; // Send to client INITSTRUCT(sP_FE2CL_REP_NANO_ACTIVE_SUCC, resp); - resp.iActiveNanoSlotNum = nano->iNanoSlotNum; + resp.iActiveNanoSlotNum = pkt->iNanoSlotNum; sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC)); + int nanoId = plr.plr.equippedNanos[pkt->iNanoSlotNum]; + sNano nano = plr.plr.Nanos[nanoId]; + + // Send to other players + for (CNSocket *s : PlayerManager::players[sock].viewable) { + INITSTRUCT(sP_FE2CL_NANO_ACTIVE, pkt); + + pkt.iPC_ID = plr.plr.iID; + pkt.Nano = nano; + + s->sendPacket((void*)&pkt, P_FE2CL_NANO_ACTIVE, sizeof(sP_FE2CL_NANO_ACTIVE)); + } + + // update player + plr.plr.nano = nanoId; + PlayerManager::updatePlayer(sock, plr.plr); + DEBUGLOG( - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << nano->iNanoSlotNum << std::endl; + std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << pkt->iNanoSlotNum << std::endl; ) } @@ -151,4 +178,4 @@ void NanoManager::resetNanoSkill(CNSocket* sock, int16_t nanoId) { // Update the player PlayerManager::updatePlayer(sock, plr); } -#pragma endregion \ No newline at end of file +#pragma endregion diff --git a/src/Player.hpp b/src/Player.hpp index 9c3c001..c80af83 100644 --- a/src/Player.hpp +++ b/src/Player.hpp @@ -14,10 +14,12 @@ struct Player { int level; int HP; - int slot; + int slot; // player slot, not nano slot sPCStyle PCStyle; sPCStyle2 PCStyle2; sNano Nanos[37]; + int equippedNanos[3]; + int nano; // active nano (index into Nanos) int x, y, z, angle; sItemBase Equip[AEQUIP_COUNT]; @@ -25,4 +27,4 @@ struct Player { bool IsGM; }; -#endif \ No newline at end of file +#endif diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index b8f8b80..d3835b6 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -125,6 +125,7 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { newPlayer.PCAppearanceData.iZ = plr.z; newPlayer.PCAppearanceData.iAngle = plr.angle; newPlayer.PCAppearanceData.PCStyle = plr.PCStyle; + newPlayer.PCAppearanceData.Nano = plr.Nanos[plr.nano]; memcpy(newPlayer.PCAppearanceData.ItemEquip, plr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); otherSock->sendPacket((void*)&newPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW)); @@ -137,6 +138,7 @@ void PlayerManager::updatePlayerPosition(CNSocket* sock, int X, int Y, int Z) { newPlayer.PCAppearanceData.iZ = otherPlr.z; newPlayer.PCAppearanceData.iAngle = otherPlr.angle; newPlayer.PCAppearanceData.PCStyle = otherPlr.PCStyle; + newPlayer.PCAppearanceData.Nano = otherPlr.Nanos[otherPlr.nano]; memcpy(newPlayer.PCAppearanceData.ItemEquip, otherPlr.Equip, sizeof(sItemBase) * AEQUIP_COUNT); sock->sendPacket((void*)&newPlayer, P_FE2CL_PC_NEW, sizeof(sP_FE2CL_PC_NEW)); @@ -552,4 +554,4 @@ void PlayerManager::updatePlayer(CNSocket* key, Player plr) { plrv.plr = plr; players[key] = plrv; -} \ No newline at end of file +} From d6b96389bededc03ff744d312fdd76bdaebba3a0 Mon Sep 17 00:00:00 2001 From: CPunch Date: Sat, 22 Aug 2020 22:15:27 -0500 Subject: [PATCH 20/22] added sanity checks to nanos --- src/NanoManager.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index a918c45..19c72cd 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -20,9 +20,13 @@ void NanoManager::nanoEquipHandler(CNSocket* sock, CNPacketData* data) { INITSTRUCT(sP_FE2CL_REP_NANO_EQUIP_SUCC, resp); Player plr = PlayerManager::getPlayer(sock); + if (nano->iNanoSlotNum > 2) + return; + resp.iNanoID = nano->iNanoID; resp.iNanoSlotNum = nano->iNanoSlotNum; + // Update player plr.equippedNanos[nano->iNanoSlotNum] = nano->iNanoID; PlayerManager::updatePlayer(sock, plr); @@ -38,6 +42,9 @@ void NanoManager::nanoUnEquipHandler(CNSocket* sock, CNPacketData* data) { INITSTRUCT(sP_FE2CL_REP_NANO_UNEQUIP_SUCC, resp); Player plr = PlayerManager::getPlayer(sock); + if (nano->iNanoSlotNum > 2) + return; + resp.iNanoSlotNum = nano->iNanoSlotNum; // update player @@ -75,7 +82,14 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { resp.iActiveNanoSlotNum = pkt->iNanoSlotNum; sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_ACTIVE_SUCC, sizeof(sP_FE2CL_REP_NANO_ACTIVE_SUCC)); + if (pkt->iNanoSlotNum > 2) + return; + int nanoId = plr.plr.equippedNanos[pkt->iNanoSlotNum]; + + if (nanoId > 36) + return; // sanity check + sNano nano = plr.plr.Nanos[nanoId]; // Send to other players @@ -131,6 +145,9 @@ void NanoManager::nanoSkillSetHandler(CNSocket* sock, CNPacketData* data) { #pragma region Helper methods void NanoManager::addNano(CNSocket* sock, int16_t nanoId, int16_t slot) { + if (nanoId > 36) + return; + Player plr = PlayerManager::getPlayer(sock); // Send to client @@ -147,6 +164,9 @@ void NanoManager::addNano(CNSocket* sock, int16_t nanoId, int16_t slot) { } void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) { + if (nanoId > 36) + return; + Player plr = PlayerManager::getPlayer(sock); sNano nano = plr.Nanos[nanoId]; @@ -169,6 +189,9 @@ void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) } void NanoManager::resetNanoSkill(CNSocket* sock, int16_t nanoId) { + if (nanoId > 36) + return; + Player plr = PlayerManager::getPlayer(sock); sNano nano = plr.Nanos[nanoId]; From 648bad443bbaa4d53effa306444e69ef8d763da3 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sun, 23 Aug 2020 09:04:38 +0200 Subject: [PATCH 21/22] Cleaned up NanoManager --- src/NanoManager.cpp | 38 ++++++++++++++++++-------------------- src/Player.hpp | 2 +- 2 files changed, 19 insertions(+), 21 deletions(-) diff --git a/src/NanoManager.cpp b/src/NanoManager.cpp index 19c72cd..453185d 100644 --- a/src/NanoManager.cpp +++ b/src/NanoManager.cpp @@ -75,7 +75,7 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { return; // malformed packet sP_CL2FE_REQ_NANO_ACTIVE* pkt = (sP_CL2FE_REQ_NANO_ACTIVE*)data->buf; - PlayerView plr = PlayerManager::players[sock]; + Player plr = PlayerManager::getPlayer(sock); // Send to client INITSTRUCT(sP_FE2CL_REP_NANO_ACTIVE_SUCC, resp); @@ -85,29 +85,29 @@ void NanoManager::nanoSummonHandler(CNSocket* sock, CNPacketData* data) { if (pkt->iNanoSlotNum > 2) return; - int nanoId = plr.plr.equippedNanos[pkt->iNanoSlotNum]; + int nanoId = plr.equippedNanos[pkt->iNanoSlotNum]; if (nanoId > 36) return; // sanity check - sNano nano = plr.plr.Nanos[nanoId]; + sNano nano = plr.Nanos[nanoId]; // Send to other players - for (CNSocket *s : PlayerManager::players[sock].viewable) { - INITSTRUCT(sP_FE2CL_NANO_ACTIVE, pkt); + for (CNSocket* s : PlayerManager::players[sock].viewable) { + INITSTRUCT(sP_FE2CL_NANO_ACTIVE, pkt); - pkt.iPC_ID = plr.plr.iID; - pkt.Nano = nano; + pkt.iPC_ID = plr.iID; + pkt.Nano = nano; - s->sendPacket((void*)&pkt, P_FE2CL_NANO_ACTIVE, sizeof(sP_FE2CL_NANO_ACTIVE)); + s->sendPacket((void*)&pkt, P_FE2CL_NANO_ACTIVE, sizeof(sP_FE2CL_NANO_ACTIVE)); } // update player - plr.plr.nano = nanoId; - PlayerManager::updatePlayer(sock, plr.plr); + plr.nano = nanoId; + PlayerManager::updatePlayer(sock, plr); DEBUGLOG( - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano slot: " << pkt->iNanoSlotNum << std::endl; + std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " requested to summon nano slot: " << pkt->iNanoSlotNum << std::endl; ) } @@ -116,7 +116,7 @@ void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { return; // malformed packet sP_CL2FE_REQ_NANO_SKILL_USE* skill = (sP_CL2FE_REQ_NANO_SKILL_USE*)data->buf; - PlayerView plr = PlayerManager::players[sock]; + Player plr = PlayerManager::getPlayer(sock); // Send to client INITSTRUCT(sP_FE2CL_NANO_SKILL_USE_SUCC, resp); @@ -125,14 +125,10 @@ void NanoManager::nanoSkillUseHandler(CNSocket* sock, CNPacketData* data) { resp.iArg3 = skill->iArg3; resp.iBulletID = skill->iBulletID; resp.iTargetCnt = skill->iTargetCnt; - resp.iPC_ID = plr.plr.iID; + resp.iPC_ID = plr.iID; resp.iNanoStamina = 150; // Hardcoded for now sock->sendPacket((void*)&resp, P_FE2CL_NANO_SKILL_USE_SUCC, sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC)); - - DEBUGLOG( - std::cout << U16toU8(plr.plr.PCStyle.szFirstName) << U16toU8(plr.plr.PCStyle.szLastName) << " requested to summon nano skill " << std::endl; - ) } void NanoManager::nanoSkillSetHandler(CNSocket* sock, CNPacketData* data) { @@ -180,21 +176,23 @@ void NanoManager::setNanoSkill(CNSocket* sock, int16_t nanoId, int16_t skillId) sock->sendPacket((void*)&resp, P_FE2CL_REP_NANO_TUNE_SUCC, sizeof(sP_FE2CL_REP_NANO_TUNE_SUCC)); + // Update the player + PlayerManager::updatePlayer(sock, plr); + DEBUGLOG( std::cout << U16toU8(plr.PCStyle.szFirstName) << U16toU8(plr.PCStyle.szLastName) << " set skill id " << skillId << " for nano: " << nanoId << std::endl; ) - // Update the player - PlayerManager::updatePlayer(sock, plr); } void NanoManager::resetNanoSkill(CNSocket* sock, int16_t nanoId) { if (nanoId > 36) return; - + Player plr = PlayerManager::getPlayer(sock); sNano nano = plr.Nanos[nanoId]; + // 0 is reset nano.iSkillID = 0; plr.Nanos[nanoId] = nano; diff --git a/src/Player.hpp b/src/Player.hpp index c80af83..28b0aac 100644 --- a/src/Player.hpp +++ b/src/Player.hpp @@ -17,7 +17,7 @@ struct Player { int slot; // player slot, not nano slot sPCStyle PCStyle; sPCStyle2 PCStyle2; - sNano Nanos[37]; + sNano Nanos[37]; // acquired nanos int equippedNanos[3]; int nano; // active nano (index into Nanos) From ba1890ff55bb1bbe0868c717cacf8eb29039a2a1 Mon Sep 17 00:00:00 2001 From: Onii-chan Date: Sun, 23 Aug 2020 09:25:42 +0200 Subject: [PATCH 22/22] Added player revive --- src/PlayerManager.cpp | 31 +++++++++++++++++++++++++------ src/PlayerManager.hpp | 1 + 2 files changed, 26 insertions(+), 6 deletions(-) diff --git a/src/PlayerManager.cpp b/src/PlayerManager.cpp index d3835b6..62bbc41 100644 --- a/src/PlayerManager.cpp +++ b/src/PlayerManager.cpp @@ -27,6 +27,7 @@ void PlayerManager::init() { REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_GOTO, PlayerManager::gotoPlayer); REGISTER_SHARD_PACKET(P_CL2FE_GM_REQ_PC_SET_VALUE, PlayerManager::setSpecialPlayer); REGISTER_SHARD_PACKET(P_CL2FE_REP_LIVE_CHECK, PlayerManager::heartbeatPlayer); + REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_REGEN, PlayerManager::revivePlayer); REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_EXIT, PlayerManager::exitGame); } @@ -170,7 +171,7 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { std::cout << "\tPC_UID: " << plr.PCStyle.iPC_UID << std::endl; ) - response.iID = rand(); + response.iID = rand(); response.uiSvrTime = getTime(); response.PCLoadData2CL.iUserLevel = 1; response.PCLoadData2CL.iHP = 1000 * plr.level; @@ -189,7 +190,7 @@ void PlayerManager::enterPlayer(CNSocket* sock, CNPacketData* data) { for (int i = 0; i < AEQUIP_COUNT; i++) response.PCLoadData2CL.aEquip[i] = plr.Equip[i]; - for (int i = 0; i < AINVEN_COUNT; i++) + for (int i = 0; i < AINVEN_COUNT; i++) response.PCLoadData2CL.aInven[i] = plr.Inven[i]; // don't ask.. @@ -237,7 +238,7 @@ void PlayerManager::loadPlayer(CNSocket* sock, CNPacketData* data) { std::cout << "\tPC_ID: " << complete->iPC_ID << std::endl; ) - response.iPC_ID = complete->iPC_ID; + response.iPC_ID = complete->iPC_ID; sock->sendPacket((void*)&response, P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, sizeof(sP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC)); } @@ -504,7 +505,7 @@ void PlayerManager::gotoPlayer(CNSocket* sock, CNPacketData* data) { std::cout << "\tZ: " << gotoData->iToZ << std::endl; ) - response.iX = gotoData->iToX; + response.iX = gotoData->iToX; response.iY = gotoData->iToY; response.iZ = gotoData->iToZ; @@ -525,7 +526,7 @@ void PlayerManager::setSpecialPlayer(CNSocket* sock, CNPacketData* data) { std::cout << "\tSetValue: " << setData->iSetValue << std::endl; ) - response.iPC_ID = setData->iPC_ID; + response.iPC_ID = setData->iPC_ID; response.iSetValue = setData->iSetValue; response.iSetValueType = setData->iSetValueType; @@ -539,7 +540,7 @@ void PlayerManager::heartbeatPlayer(CNSocket* sock, CNPacketData* data) { void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { if (data->size != sizeof(sP_CL2FE_REQ_PC_EXIT)) return; - + sP_CL2FE_REQ_PC_EXIT* exitData = (sP_CL2FE_REQ_PC_EXIT*)data->buf; INITSTRUCT(sP_FE2CL_REP_PC_EXIT_SUCC, response); @@ -549,9 +550,27 @@ void PlayerManager::exitGame(CNSocket* sock, CNPacketData* data) { sock->sendPacket((void*)&response, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC)); } +void PlayerManager::revivePlayer(CNSocket* sock, CNPacketData* data) { + if (data->size != sizeof(sP_CL2FE_REQ_PC_REGEN)) + return; + + Player plr = PlayerManager::getPlayer(sock); + + sP_CL2FE_REQ_PC_REGEN* reviveData = (sP_CL2FE_REQ_PC_REGEN*)data->buf; + INITSTRUCT(sP_FE2CL_REP_PC_REGEN_SUCC, response); + response.bMoveLocation = reviveData->eIL; + response.PCRegenData.iMapNum = reviveData->iIndex; + response.PCRegenData.iHP = 1000 * plr.level; + + sock->sendPacket((void*)&response, P_FE2CL_REP_PC_REGEN_SUCC, sizeof(sP_FE2CL_REP_PC_REGEN_SUCC)); +} + +#pragma region Helper methods + void PlayerManager::updatePlayer(CNSocket* key, Player plr) { PlayerView plrv = players[key]; plrv.plr = plr; players[key] = plrv; } +#pragma endregion \ No newline at end of file diff --git a/src/PlayerManager.hpp b/src/PlayerManager.hpp index 34cfb6a..6a3040d 100644 --- a/src/PlayerManager.hpp +++ b/src/PlayerManager.hpp @@ -41,6 +41,7 @@ namespace PlayerManager { void gotoPlayer(CNSocket* sock, CNPacketData* data); void setSpecialPlayer(CNSocket* sock, CNPacketData* data); void heartbeatPlayer(CNSocket* sock, CNPacketData* data); + void revivePlayer(CNSocket* sock, CNPacketData* data); void exitGame(CNSocket* sock, CNPacketData* data); }