Optimize performance

Introduces a generic, fixed-size `Bucket` type in place of the inner
vector. This does add size generics but I think it's a very good
tradeoff considering how performance-sensitive this codepath is.

src/Abilities.cpp

@@ -334,8 +334,8 @@ void Abilities::useNanoSkill(CNSocket* sock, SkillData* skill, sNano& nano, std:
     size_t resplen = sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC);
     for(SkillResult& sr : results)
         resplen += sr.size;
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NANO_SKILL_USE_SUCC* pkt = (sP_FE2CL_NANO_SKILL_USE_SUCC*)respbuf;
     pkt->iPC_ID = plr->iID;
@@ -379,8 +379,8 @@ void Abilities::useNPCSkill(EntityRef npc, int skillID, std::vector<ICombatant*>
     size_t resplen = sizeof(sP_FE2CL_NPC_SKILL_HIT);
     for(SkillResult& sr : results)
         resplen += sr.size;
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NPC_SKILL_HIT* pkt = (sP_FE2CL_NPC_SKILL_HIT*)respbuf;
     pkt->iNPC_ID = npc.id;

src/Bucket.hpp

@@ -3,8 +3,6 @@
 #include <array>
 #include <optional>
 
-#include <assert.h>
-
 template<class T, size_t N>
 class Bucket {
     std::array<T, N> buf;
@@ -15,9 +13,10 @@ public:
     }
 
     void add(const T& item) {
-        assert(sz < N);
+        if (sz < N) {
             buf[sz++] = item;
         }
+    }
 
     std::optional<T> get(size_t idx) const {
         if (idx < sz) {

src/Buddies.cpp

@@ -41,9 +41,9 @@ void Buddies::sendBuddyList(CNSocket* sock) {
 
     // initialize response struct
     size_t resplen = sizeof(sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC) + buddyCnt * sizeof(sBuddyBaseInfo);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
 
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC* resp = (sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC*)respbuf;
     sBuddyBaseInfo* respdata = (sBuddyBaseInfo*)(respbuf + sizeof(sP_FE2CL_REP_PC_BUDDYLIST_INFO_SUCC));

src/Buffs.cpp

@@ -178,9 +178,9 @@ void Buffs::tickDrain(EntityRef self, Buff* buff, int mult) {
     int dealt = combatant->takeDamage(buff->getLastSource(), damage);
 
     size_t resplen = sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK) + sizeof(sSkillResult_Damage);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK *pkt = (sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK*)respbuf;
     pkt->iID = self.id;

src/Chunking.cpp

@@ -13,12 +13,11 @@ using namespace Chunking;
  * The initial chunkPos value before a player is placed into the world.
  */
 const ChunkPos Chunking::INVALID_CHUNK = {};
-constexpr size_t MAX_PC_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sPCAppearanceData);
+constexpr size_t MAX_PC_PER_AROUND = (CN_PACKET_BUFFER_SIZE - sizeof(int32_t)) / sizeof(sPCAppearanceData);
-constexpr size_t MAX_NPC_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sNPCAppearanceData);
+constexpr size_t MAX_NPC_PER_AROUND = (CN_PACKET_BUFFER_SIZE - sizeof(int32_t)) / sizeof(sNPCAppearanceData);
-constexpr size_t MAX_SHINY_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sShinyAppearanceData);
+constexpr size_t MAX_SHINY_PER_AROUND = (CN_PACKET_BUFFER_SIZE - sizeof(int32_t)) / sizeof(sShinyAppearanceData);
-constexpr size_t MAX_TRANSPORTATION_PER_AROUND = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(sTransportationAppearanceData);
+constexpr size_t MAX_TRANSPORTATION_PER_AROUND = (CN_PACKET_BUFFER_SIZE - sizeof(int32_t)) / sizeof(sTransportationAppearanceData);
-constexpr size_t MAX_IDS_PER_AROUND_DEL = (CN_PACKET_BODY_SIZE - sizeof(int32_t)) / sizeof(int32_t);
+constexpr size_t MAX_IDS_PER_AROUND_DEL = (CN_PACKET_BUFFER_SIZE - sizeof(int32_t)) / sizeof(int32_t);
-constexpr size_t MAX_TRANSPORTATION_IDS_PER_AROUND_DEL = MAX_IDS_PER_AROUND_DEL - 1; // 1 less for eTT
 
 std::map<ChunkPos, Chunk*> Chunking::chunks;
 
@@ -84,12 +83,12 @@ void Chunking::untrackEntity(ChunkPos chunkPos, const EntityRef ref) {
 }
 
 template<class T, size_t N>
-static void sendAroundPackets(const EntityRef recipient, std::vector<Bucket<T, N>>& buckets, uint32_t packetId) {
+static void sendAroundPacket(const EntityRef recipient, std::vector<Bucket<T, N>>& buckets, uint32_t packetId) {
     assert(recipient.kind == EntityKind::PLAYER);
 
-    uint8_t pktBuf[CN_PACKET_BODY_SIZE];
+    uint8_t pktBuf[CN_PACKET_BUFFER_SIZE];
     for (const auto& bucket : buckets) {
-        memset(pktBuf, 0, CN_PACKET_BODY_SIZE);
+        memset(pktBuf, 0, CN_PACKET_BUFFER_SIZE);
         int count = bucket.size();
         *((int32_t*)pktBuf) = count;
         T* data = (T*)(pktBuf + sizeof(int32_t));
@@ -101,17 +100,17 @@ static void sendAroundPackets(const EntityRef recipient, std::vector<Bucket<T, N
 }
 
 template<size_t N>
-static void sendAroundDelPackets(const EntityRef recipient, std::vector<Bucket<int32_t, N>>& buckets, uint32_t packetId) {
+static void sendAroundDelPacket(const EntityRef recipient, std::vector<Bucket<int32_t, N>>& buckets, bool isTransportation, uint32_t packetId) {
     assert(recipient.kind == EntityKind::PLAYER);
 
-    uint8_t pktBuf[CN_PACKET_BODY_SIZE];
+    uint8_t pktBuf[CN_PACKET_BUFFER_SIZE];
     for (const auto& bucket : buckets) {
-        memset(pktBuf, 0, CN_PACKET_BODY_SIZE);
+        memset(pktBuf, 0, CN_PACKET_BUFFER_SIZE);
         int count = bucket.size();
         assert(count <= N);
 
         size_t baseSize;
-        if (packetId == P_FE2CL_AROUND_DEL_TRANSPORTATION) {
+        if (isTransportation) {
             sP_FE2CL_AROUND_DEL_TRANSPORTATION* pkt = (sP_FE2CL_AROUND_DEL_TRANSPORTATION*)pktBuf;
             pkt->eTT = 3;
             pkt->iCnt = count;
@@ -132,21 +131,23 @@ static void sendAroundDelPackets(const EntityRef recipient, std::vector<Bucket<i
 template<class T, size_t N>
 static void bufferAppearanceData(std::vector<Bucket<T, N>>& buckets, const T& data) {
     if (buckets.empty())
-        buckets.push_back({});
+        buckets.push_back(Bucket<T, N>());
-    auto& bucket = buckets[buckets.size() - 1];
+    Bucket<T, N>& bucket = buckets[buckets.size() - 1];
+    assert(!bucket.isFull());
     bucket.add(data);
     if (bucket.isFull())
-        buckets.push_back({});
+        buckets.push_back(Bucket<T, N>());
 }
 
 template<size_t N>
 static void bufferIdForDisappearance(std::vector<Bucket<int32_t, N>>& buckets, int32_t id) {
     if (buckets.empty())
-        buckets.push_back({});
+        buckets.push_back(Bucket<int32_t, N>());
-    auto& bucket = buckets[buckets.size() - 1];
+    Bucket<int32_t, N>& bucket = buckets[buckets.size() - 1];
+    assert(!bucket.isFull());
     bucket.add(id);
     if (bucket.isFull())
-        buckets.push_back({});
+        buckets.push_back(Bucket<int32_t, N>());
 }
 
 void Chunking::addEntityToChunks(std::set<Chunk*> chnks, const EntityRef ref) {
@@ -176,7 +177,8 @@ void Chunking::addEntityToChunks(std::set<Chunk*> chnks, const EntityRef ref) {
                 sNPCAppearanceData npcData;
                 sShinyAppearanceData eggData;
                 sTransportationAppearanceData busData;
-                switch(otherRef.kind) {
+                switch(otherRef.kind)
+                {
                 case EntityKind::PLAYER:
                     pcData = dynamic_cast<Player*>(other)->getAppearanceData();
                     bufferAppearanceData(pcAppearances, pcData);
@@ -214,16 +216,17 @@ void Chunking::addEntityToChunks(std::set<Chunk*> chnks, const EntityRef ref) {
         }
     }
 
-    if (ref.kind == EntityKind::PLAYER) {
+    if (ref.kind != EntityKind::PLAYER)
+        return; // nothing to send
+
     if (!pcAppearances.empty())
-            sendAroundPackets(ref, pcAppearances, P_FE2CL_PC_AROUND);
+        sendAroundPacket(ref, pcAppearances, P_FE2CL_PC_AROUND);
     if (!npcAppearances.empty())
-            sendAroundPackets(ref, npcAppearances, P_FE2CL_NPC_AROUND);
+        sendAroundPacket(ref, npcAppearances, P_FE2CL_NPC_AROUND);
     if (!shinyAppearances.empty())
-            sendAroundPackets(ref, shinyAppearances, P_FE2CL_SHINY_AROUND);
+        sendAroundPacket(ref, shinyAppearances, P_FE2CL_SHINY_AROUND);
     if (!transportationAppearances.empty())
-            sendAroundPackets(ref, transportationAppearances, P_FE2CL_TRANSPORTATION_AROUND);
+        sendAroundPacket(ref, transportationAppearances, P_FE2CL_TRANSPORTATION_AROUND);
-    }
 }
 
 void Chunking::removeEntityFromChunks(std::set<Chunk*> chnks, const EntityRef ref) {
@@ -233,7 +236,7 @@ void Chunking::removeEntityFromChunks(std::set<Chunk*> chnks, const EntityRef re
     std::vector<Bucket<int32_t, MAX_IDS_PER_AROUND_DEL>> pcDisappearances;
     std::vector<Bucket<int32_t, MAX_IDS_PER_AROUND_DEL>> npcDisappearances;
     std::vector<Bucket<int32_t, MAX_IDS_PER_AROUND_DEL>> shinyDisappearances;
-    std::vector<Bucket<int32_t, MAX_TRANSPORTATION_IDS_PER_AROUND_DEL>> transportationDisappearances;
+    std::vector<Bucket<int32_t, MAX_IDS_PER_AROUND_DEL - 1>> transportationDisappearances;
     for (Chunk *chunk : chnks) {
         for (const EntityRef otherRef : chunk->entities) {
             // skip oneself
@@ -250,7 +253,8 @@ void Chunking::removeEntityFromChunks(std::set<Chunk*> chnks, const EntityRef re
             // notify this *player* of the departure of all visible Entities
             if (ref.kind == EntityKind::PLAYER && other->isExtant()) {
                 int32_t id;
-                switch(otherRef.kind) {
+                switch(otherRef.kind)
+                {
                 case EntityKind::PLAYER:
                     id = dynamic_cast<Player*>(other)->iID;
                     bufferIdForDisappearance(pcDisappearances, id);
@@ -282,16 +286,17 @@ void Chunking::removeEntityFromChunks(std::set<Chunk*> chnks, const EntityRef re
         }
     }
 
-    if (ref.kind == EntityKind::PLAYER) {
+    if (ref.kind != EntityKind::PLAYER)
+        return; // nothing to send
+
     if (!pcDisappearances.empty())
-            sendAroundDelPackets(ref, pcDisappearances, P_FE2CL_AROUND_DEL_PC);
+        sendAroundDelPacket(ref, pcDisappearances, false, P_FE2CL_AROUND_DEL_PC);
     if (!npcDisappearances.empty())
-            sendAroundDelPackets(ref, npcDisappearances, P_FE2CL_AROUND_DEL_NPC);
+        sendAroundDelPacket(ref, npcDisappearances, false, P_FE2CL_AROUND_DEL_NPC);
     if (!shinyDisappearances.empty())
-            sendAroundDelPackets(ref, shinyDisappearances, P_FE2CL_AROUND_DEL_SHINY);
+        sendAroundDelPacket(ref, shinyDisappearances, false, P_FE2CL_AROUND_DEL_SHINY);
     if (!transportationDisappearances.empty())
-            sendAroundDelPackets(ref, transportationDisappearances, P_FE2CL_AROUND_DEL_TRANSPORTATION);
+        sendAroundDelPacket(ref, transportationDisappearances, true, P_FE2CL_AROUND_DEL_TRANSPORTATION);
-    }
 }
 
 static void emptyChunk(ChunkPos chunkPos) {

src/Combat.cpp

@@ -539,9 +539,9 @@ static void dealGooDamage(CNSocket *sock) {
         return; // ignore completely
 
     size_t resplen = sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK) + sizeof(sSkillResult_DotDamage);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK *pkt = (sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK*)respbuf;
     sSkillResult_DotDamage *dmg = (sSkillResult_DotDamage*)(respbuf + sizeof(sP_FE2CL_CHAR_TIME_BUFF_TIME_TICK));
@@ -633,9 +633,9 @@ static void pcAttackChars(CNSocket *sock, CNPacketData *data) {
 
     // initialize response struct
     size_t resplen = sizeof(sP_FE2CL_PC_ATTACK_CHARs_SUCC) + pkt->iTargetCnt * sizeof(sAttackResult);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
 
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_PC_ATTACK_CHARs_SUCC *resp = (sP_FE2CL_PC_ATTACK_CHARs_SUCC*)respbuf;
     sAttackResult *respdata = (sAttackResult*)(respbuf+sizeof(sP_FE2CL_PC_ATTACK_CHARs_SUCC));
@@ -847,9 +847,9 @@ static void projectileHit(CNSocket* sock, CNPacketData* data) {
      */
 
     size_t resplen = sizeof(sP_FE2CL_PC_GRENADE_STYLE_HIT) + pkt->iTargetCnt * sizeof(sAttackResult);
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
 
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_PC_GRENADE_STYLE_HIT* resp = (sP_FE2CL_PC_GRENADE_STYLE_HIT*)respbuf;
     sAttackResult* respdata = (sAttackResult*)(respbuf + sizeof(sP_FE2CL_PC_GRENADE_STYLE_HIT));

src/Eggs.cpp

@@ -87,8 +87,8 @@ void Eggs::eggBuffPlayer(CNSocket* sock, int skillId, int eggId, int duration) {
 
     // initialize response struct
     size_t resplen = sizeof(sP_FE2CL_NPC_SKILL_HIT) + result.size;
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NPC_SKILL_HIT* pkt = (sP_FE2CL_NPC_SKILL_HIT*)respbuf;
     pkt->iNPC_ID = eggId;
@@ -183,7 +183,7 @@ static void eggPickup(CNSocket* sock, CNPacketData* data) {
     // drop
     if (type->dropCrateId != 0) {
         const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-        assert(resplen < CN_PACKET_BODY_SIZE);
+        assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
         // we know it's only one trailing struct, so we can skip full validation
 
         uint8_t respbuf[resplen]; // not a variable length array, don't worry

src/Groups.cpp

@@ -87,8 +87,8 @@ void Groups::addToGroup(Group* group, EntityRef member) {
         size_t pcCount = pcs.size();
         size_t npcCount = npcs.size();
 
-        uint8_t respbuf[CN_PACKET_BODY_SIZE];
+        uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-        memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+        memset(respbuf, 0, CN_PACKET_BUFFER_SIZE);
         sP_FE2CL_PC_GROUP_JOIN* pkt = (sP_FE2CL_PC_GROUP_JOIN*)respbuf;
 
         pkt->iID_NewMember = PlayerManager::getPlayer(member.sock)->iID;
@@ -143,8 +143,8 @@ bool Groups::removeFromGroup(Group* group, EntityRef member) {
         size_t pcCount = pcs.size();
         size_t npcCount = npcs.size();
 
-        uint8_t respbuf[CN_PACKET_BODY_SIZE];
+        uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-        memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+        memset(respbuf, 0, CN_PACKET_BUFFER_SIZE);
         sP_FE2CL_PC_GROUP_LEAVE* pkt = (sP_FE2CL_PC_GROUP_LEAVE*)respbuf;
 
         pkt->iID_LeaveMember = PlayerManager::getPlayer(member.sock)->iID;
@@ -288,8 +288,8 @@ void Groups::groupTickInfo(CNSocket* sock) {
     size_t pcCount = pcs.size();
     size_t npcCount = npcs.size();
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, CN_PACKET_BUFFER_SIZE);
     sP_FE2CL_PC_GROUP_MEMBER_INFO* pkt = (sP_FE2CL_PC_GROUP_MEMBER_INFO*)respbuf;
 
     pkt->iID = plr->iID;

src/Items.cpp

@@ -46,7 +46,7 @@ static void nanoCapsuleHandler(CNSocket* sock, int slot, sItemBase *chest) {
 
     // in order to remove capsule form inventory, we have to send item reward packet with empty item
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
 
     // we know it's only one trailing struct, so we can skip full validation
     uint8_t respbuf[resplen]; // not a variable length array, don't worry
@@ -475,8 +475,8 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
     if (gumball.iOpt == 0)
         gumball = {};
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_REP_PC_ITEM_USE_SUCC *resp = (sP_FE2CL_REP_PC_ITEM_USE_SUCC*)respbuf;
     sSkillResult_Buff *respdata = (sSkillResult_Buff*)(respbuf+sizeof(sP_FE2CL_NANO_SKILL_USE_SUCC));
@@ -556,7 +556,7 @@ static void chestOpenHandler(CNSocket *sock, CNPacketData *data) {
 
     // item giving packet
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
     // we know it's only one trailing struct, so we can skip full validation
 
     uint8_t respbuf[resplen]; // not a variable length array, don't worry
@@ -645,7 +645,7 @@ void Items::checkItemExpire(CNSocket* sock, Player* player) {
     */
 
     const size_t resplen = sizeof(sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM) + sizeof(sTimeLimitItemDeleteInfo2CL);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
     // we know it's only one trailing struct, so we can skip full validation
     uint8_t respbuf[resplen]; // not a variable length array, don't worry
     auto packet = (sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM*)respbuf;
@@ -715,7 +715,7 @@ static void giveSingleDrop(CNSocket *sock, Mob* mob, int mobDropId, const DropRo
     Player *plr = PlayerManager::getPlayer(sock);
 
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE - 8);
     // we know it's only one trailing struct, so we can skip full validation
 
     uint8_t respbuf[resplen]; // not a variable length array, don't worry

src/Missions.cpp

@@ -64,7 +64,7 @@ static bool isQuestItemFull(CNSocket* sock, int itemId, int itemCount) {
 static void dropQuestItem(CNSocket *sock, int task, int count, int id, int mobid) {
     std::cout << "Altered item id " << id << " by " << count << " for task id " << task << std::endl;
     const size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE);
     // we know it's only one trailing struct, so we can skip full validation
 
     Player *plr = PlayerManager::getPlayer(sock);
@@ -152,14 +152,14 @@ static int giveMissionReward(CNSocket *sock, int task, int choice=0) {
         plr->Inven[slots[i]] = { 999, 999, 999, 0 }; // temp item; overwritten later
     }
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
     size_t resplen = sizeof(sP_FE2CL_REP_REWARD_ITEM) + nrewards * sizeof(sItemReward);
-    assert(resplen < CN_PACKET_BODY_SIZE);
+    assert(resplen < CN_PACKET_BUFFER_SIZE);
     sP_FE2CL_REP_REWARD_ITEM *resp = (sP_FE2CL_REP_REWARD_ITEM *)respbuf;
     sItemReward *item = (sItemReward *)(respbuf + sizeof(sP_FE2CL_REP_REWARD_ITEM));
 
     // don't forget to zero the buffer!
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     // update player
     plr->money += reward->money;

src/MobAI.cpp

@@ -238,8 +238,8 @@ static void dealCorruption(Mob *mob, std::vector<int> targetData, int skillID, i
         return;
     }
 
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
+    uint8_t respbuf[CN_PACKET_BUFFER_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    memset(respbuf, 0, resplen);
 
     sP_FE2CL_NPC_SKILL_CORRUPTION_HIT *resp = (sP_FE2CL_NPC_SKILL_CORRUPTION_HIT*)respbuf;
     sCAttackResult *respdata = (sCAttackResult*)(respbuf+sizeof(sP_FE2CL_NPC_SKILL_CORRUPTION_HIT));

src/core/CNProtocol.hpp

@@ -95,14 +95,14 @@ inline constexpr bool isOutboundPacketID(uint32_t id) {
 // for outbound packets
 inline constexpr bool validOutVarPacket(size_t base, size_t npayloads, size_t plsize) {
     // check for multiplication overflow
-    if (npayloads > 0 && (CN_PACKET_BODY_SIZE) / (size_t)npayloads < plsize)
+    if (npayloads > 0 && (CN_PACKET_BUFFER_SIZE - 8) / (size_t)npayloads < plsize)
         return false;
 
     // it's safe to multiply
     size_t trailing = npayloads * plsize;
 
     // does it fit in a packet?
-    if (base + trailing > CN_PACKET_BODY_SIZE)
+    if (base + trailing > CN_PACKET_BUFFER_SIZE - 8)
         return false;
 
     // everything is a-ok!
@@ -112,14 +112,14 @@ inline constexpr bool validOutVarPacket(size_t base, size_t npayloads, size_t pl
 // for inbound packets
 inline constexpr bool validInVarPacket(size_t base, size_t npayloads, size_t plsize, size_t datasize) {
     // check for multiplication overflow
-    if (npayloads > 0 && CN_PACKET_BODY_SIZE / (size_t)npayloads < plsize)
+    if (npayloads > 0 && (CN_PACKET_BUFFER_SIZE - 8) / (size_t)npayloads < plsize)
         return false;
 
     // it's safe to multiply
     size_t trailing = npayloads * plsize;
 
     // make sure size is exact
-    // datasize has already been validated against CN_PACKET_BODY_SIZE
+    // datasize has already been validated against CN_PACKET_BUFFER_SIZE
     if (datasize != base + trailing)
         return false;
 

src/core/CNStructs.hpp

@@ -29,8 +29,8 @@
 #define INITSTRUCT(T, x) T x; \
     memset(&x, 0, sizeof(T));
 
-#define INITVARPACKET(_buf, _Pkt, _pkt, _Trailer, _trailer) uint8_t _buf[CN_PACKET_BODY_SIZE]; \
+#define INITVARPACKET(_buf, _Pkt, _pkt, _Trailer, _trailer) uint8_t _buf[CN_PACKET_BUFFER_SIZE]; \
-    memset(&_buf, 0, CN_PACKET_BODY_SIZE); \
+    memset(&_buf, 0, CN_PACKET_BUFFER_SIZE); \
     auto _pkt = (_Pkt*)_buf; \
     auto _trailer = (_Trailer*)(_pkt + 1);
 

src/core/Defines.hpp

@@ -942,8 +942,3 @@ enum {
 
     N_PACKETS = N_CL2LS + N_CL2FE + N_FE2CL + N_LS2CL
 };
-
-/*
- * Usable space in the packet buffer = CN_PACKET_BUFFER_SIZE - type - size
- */
-constexpr size_t CN_PACKET_BODY_SIZE = CN_PACKET_BUFFER_SIZE - 2 * sizeof(int32_t);