diff --git a/src/Buddies.cpp b/src/Buddies.cpp
index 9c065d1..25f19cc 100644
--- a/src/Buddies.cpp
+++ b/src/Buddies.cpp
@@ -87,7 +87,7 @@ void Buddies::refreshBuddyList(CNSocket* sock) {
 
 // Buddy request
 static void requestBuddy(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_REQUEST_MAKE_BUDDY* req = (sP_CL2FE_REQ_REQUEST_MAKE_BUDDY*)data->buf;
+    auto req = (sP_CL2FE_REQ_REQUEST_MAKE_BUDDY*)data->buf;
 
     Player* plr = PlayerManager::getPlayer(sock);
     Player* otherPlr = PlayerManager::getPlayerFromID(req->iBuddyID);
@@ -98,7 +98,7 @@ static void requestBuddy(CNSocket* sock, CNPacketData* data) {
     if (getAvailableBuddySlot(plr) == -1 || getAvailableBuddySlot(otherPlr) == -1)
     {
         INITSTRUCT(sP_FE2CL_REP_REQUEST_MAKE_BUDDY_FAIL, failResp);
-        sock->sendPacket((void*)&failResp, P_FE2CL_REP_REQUEST_MAKE_BUDDY_FAIL, sizeof(sP_FE2CL_REP_REQUEST_MAKE_BUDDY_FAIL));
+        sock->sendPacket(failResp, P_FE2CL_REP_REQUEST_MAKE_BUDDY_FAIL);
         return;
     }
 
@@ -118,14 +118,14 @@ static void requestBuddy(CNSocket* sock, CNPacketData* data) {
 
     std::cout << "Buddy ID: " << req->iBuddyID << std::endl;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC));
-    otherSock->sendPacket((void*)&otherResp, P_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC_TO_ACCEPTER, sizeof(sP_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC_TO_ACCEPTER));
+    sock->sendPacket(resp, P_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC);
+    otherSock->sendPacket(otherResp, P_FE2CL_REP_REQUEST_MAKE_BUDDY_SUCC_TO_ACCEPTER);
 
 }
 
 // Sending buddy request by player name
 static void reqBuddyByName(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_FIND_NAME_MAKE_BUDDY* pkt = (sP_CL2FE_REQ_PC_FIND_NAME_MAKE_BUDDY*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_FIND_NAME_MAKE_BUDDY*)data->buf;
     Player* plrReq = PlayerManager::getPlayer(sock);
 
     INITSTRUCT(sP_FE2CL_REP_PC_FIND_NAME_MAKE_BUDDY_SUCC, resp);
@@ -143,12 +143,12 @@ static void reqBuddyByName(CNSocket* sock, CNPacketData* data) {
 
     memcpy(resp.szFirstName, plrReq->PCStyle.szFirstName, sizeof(plrReq->PCStyle.szFirstName));
     memcpy(resp.szLastName, plrReq->PCStyle.szLastName, sizeof(plrReq->PCStyle.szLastName));
-    otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_FIND_NAME_MAKE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_PC_FIND_NAME_MAKE_BUDDY_SUCC));
+    otherSock->sendPacket(resp, P_FE2CL_REP_PC_FIND_NAME_MAKE_BUDDY_SUCC);
 }
 
 // Accepting buddy request
 static void reqAcceptBuddy(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_ACCEPT_MAKE_BUDDY* req = (sP_CL2FE_REQ_ACCEPT_MAKE_BUDDY*)data->buf;
+    auto req = (sP_CL2FE_REQ_ACCEPT_MAKE_BUDDY*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
     Player* otherPlr = PlayerManager::getPlayerFromID(req->iBuddyID);
 
@@ -177,7 +177,7 @@ static void reqAcceptBuddy(CNSocket* sock, CNPacketData* data) {
         resp.BuddyInfo.iNameCheckFlag = otherPlr->PCStyle.iNameCheck;
         memcpy(resp.BuddyInfo.szFirstName, otherPlr->PCStyle.szFirstName, sizeof(resp.BuddyInfo.szFirstName));
         memcpy(resp.BuddyInfo.szLastName, otherPlr->PCStyle.szLastName, sizeof(resp.BuddyInfo.szLastName));
-        sock->sendPacket((void*)&resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC));
+        sock->sendPacket(resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC);
         plr->buddyIDs[slotA] = otherPlr->PCStyle.iPC_UID;
         //std::cout << "Buddy's ID: " << plr->buddyIDs[slotA] << std::endl;
         
@@ -192,7 +192,7 @@ static void reqAcceptBuddy(CNSocket* sock, CNPacketData* data) {
         resp.BuddyInfo.iNameCheckFlag = plr->PCStyle.iNameCheck;
         memcpy(resp.BuddyInfo.szFirstName, plr->PCStyle.szFirstName, sizeof(resp.BuddyInfo.szFirstName));
         memcpy(resp.BuddyInfo.szLastName, plr->PCStyle.szLastName, sizeof(resp.BuddyInfo.szLastName));
-        otherSock->sendPacket((void*)&resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC));
+        otherSock->sendPacket(resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC);
         otherPlr->buddyIDs[slotB] = plr->PCStyle.iPC_UID;
         //std::cout << "Buddy's ID: " << plr->buddyIDs[slotB] << std::endl;
 
@@ -207,14 +207,14 @@ static void reqAcceptBuddy(CNSocket* sock, CNPacketData* data) {
         declineResp.iBuddyID = req->iBuddyID;
         declineResp.iBuddyPCUID = req->iBuddyPCUID;
 
-        otherSock->sendPacket((void*)&declineResp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_FAIL, sizeof(sP_FE2CL_REP_ACCEPT_MAKE_BUDDY_FAIL));
+        otherSock->sendPacket(declineResp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_FAIL);
     }
 
 }
 
 // Accepting buddy request from the find name request
 static void reqFindNameBuddyAccept(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_FIND_NAME_ACCEPT_BUDDY* pkt = (sP_CL2FE_REQ_PC_FIND_NAME_ACCEPT_BUDDY*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_FIND_NAME_ACCEPT_BUDDY*)data->buf;
 
     Player* plrReq = PlayerManager::getPlayer(sock);
 
@@ -246,7 +246,7 @@ static void reqFindNameBuddyAccept(CNSocket* sock, CNPacketData* data) {
         resp.BuddyInfo.iNameCheckFlag = otherPlr->PCStyle.iNameCheck;
         memcpy(resp.BuddyInfo.szFirstName, otherPlr->PCStyle.szFirstName, sizeof(resp.BuddyInfo.szFirstName));
         memcpy(resp.BuddyInfo.szLastName, otherPlr->PCStyle.szLastName, sizeof(resp.BuddyInfo.szLastName));
-        sock->sendPacket((void*)&resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC));
+        sock->sendPacket(resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC);
         plrReq->buddyIDs[slotA] = otherPlr->PCStyle.iPC_UID;
         //std::cout << "Buddy's ID: " << plr->buddyIDs[slotA] << std::endl;
 
@@ -261,7 +261,7 @@ static void reqFindNameBuddyAccept(CNSocket* sock, CNPacketData* data) {
         resp.BuddyInfo.iNameCheckFlag = plrReq->PCStyle.iNameCheck;
         memcpy(resp.BuddyInfo.szFirstName, plrReq->PCStyle.szFirstName, sizeof(resp.BuddyInfo.szFirstName));
         memcpy(resp.BuddyInfo.szLastName, plrReq->PCStyle.szLastName, sizeof(resp.BuddyInfo.szLastName));
-        otherSock->sendPacket((void*)&resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC));
+        otherSock->sendPacket(resp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_SUCC);
         otherPlr->buddyIDs[slotB] = plrReq->PCStyle.iPC_UID;
         //std::cout << "Buddy's ID: " << plr->buddyIDs[slotB] << std::endl;
 
@@ -274,7 +274,7 @@ static void reqFindNameBuddyAccept(CNSocket* sock, CNPacketData* data) {
 
         declineResp.iErrorCode = 6; // Buddy declined notification
         declineResp.iBuddyPCUID = pkt->iBuddyPCUID;
-        otherSock->sendPacket((void*)&declineResp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_FAIL, sizeof(sP_FE2CL_REP_ACCEPT_MAKE_BUDDY_FAIL));
+        otherSock->sendPacket(declineResp, P_FE2CL_REP_ACCEPT_MAKE_BUDDY_FAIL);
     }
 
 }
@@ -299,12 +299,12 @@ static void reqPktGetBuddyState(CNSocket* sock, CNPacketData* data) {
         resp.aBuddyID[slot] = plr->buddyIDs[slot];
     }
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_GET_BUDDY_STATE_SUCC, sizeof(sP_FE2CL_REP_GET_BUDDY_STATE_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_GET_BUDDY_STATE_SUCC);
 }
 
 // Blocking the buddy
 static void reqBuddyBlock(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_SET_BUDDY_BLOCK* pkt = (sP_CL2FE_REQ_SET_BUDDY_BLOCK*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_SET_BUDDY_BLOCK*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     // sanity checks
@@ -323,7 +323,7 @@ static void reqBuddyBlock(CNSocket* sock, CNPacketData* data) {
     INITSTRUCT(sP_FE2CL_REP_SET_BUDDY_BLOCK_SUCC, resp);
     resp.iBuddyPCUID = pkt->iBuddyPCUID;
     resp.iBuddySlot = pkt->iBuddySlot;
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_SET_BUDDY_BLOCK_SUCC, sizeof(sP_FE2CL_REP_SET_BUDDY_BLOCK_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_SET_BUDDY_BLOCK_SUCC);
 
     // notify the other player he isn't a buddy anymore
     INITSTRUCT(sP_FE2CL_REP_REMOVE_BUDDY_SUCC, otherResp);
@@ -339,7 +339,7 @@ static void reqBuddyBlock(CNSocket* sock, CNPacketData* data) {
             otherPlr->buddyIDs[i] = 0;
             // broadcast
             otherResp.iBuddySlot = i;
-            otherSock->sendPacket((void*)&otherResp, P_FE2CL_REP_REMOVE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_REMOVE_BUDDY_SUCC));
+            otherSock->sendPacket(otherResp, P_FE2CL_REP_REMOVE_BUDDY_SUCC);
             return;
         }
     }
@@ -347,7 +347,7 @@ static void reqBuddyBlock(CNSocket* sock, CNPacketData* data) {
 
 // block non-buddy
 static void reqPlayerBlock(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_SET_PC_BLOCK* pkt = (sP_CL2FE_REQ_SET_PC_BLOCK*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_SET_PC_BLOCK*)data->buf;
 
     Player* plr = PlayerManager::getPlayer(sock);
     int buddySlot = getAvailableBuddySlot(plr);
@@ -367,13 +367,13 @@ static void reqPlayerBlock(CNSocket* sock, CNPacketData* data) {
     resp.iBlock_PCUID = pkt->iBlock_PCUID;
     resp.iBuddySlot = buddySlot;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_SET_PC_BLOCK_SUCC, sizeof(sP_FE2CL_REP_SET_PC_BLOCK_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_SET_PC_BLOCK_SUCC);
 }
 
 // Deleting the buddy
 static void reqBuddyDelete(CNSocket* sock, CNPacketData* data) {
     // note! this packet is used both for removing buddies and blocks
-    sP_CL2FE_REQ_REMOVE_BUDDY* pkt = (sP_CL2FE_REQ_REMOVE_BUDDY*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_REMOVE_BUDDY*)data->buf;
 
     Player* plr = PlayerManager::getPlayer(sock);
 
@@ -388,7 +388,7 @@ static void reqBuddyDelete(CNSocket* sock, CNPacketData* data) {
     plr->buddyIDs[resp.iBuddySlot] = 0;
     plr->isBuddyBlocked[resp.iBuddySlot] = false;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_REMOVE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_REMOVE_BUDDY_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_REMOVE_BUDDY_SUCC);
     
     // remove record from db
     Database::removeBuddyship(plr->PCStyle.iPC_UID, pkt->iBuddyPCUID);
@@ -411,7 +411,7 @@ static void reqBuddyDelete(CNSocket* sock, CNPacketData* data) {
             otherPlr->buddyIDs[i] = 0;
             // broadcast
             resp.iBuddySlot = i;
-            otherSock->sendPacket((void*)&resp, P_FE2CL_REP_REMOVE_BUDDY_SUCC, sizeof(sP_FE2CL_REP_REMOVE_BUDDY_SUCC));
+            otherSock->sendPacket(resp, P_FE2CL_REP_REMOVE_BUDDY_SUCC);
             return;
         }
     }
@@ -421,7 +421,7 @@ static void reqBuddyDelete(CNSocket* sock, CNPacketData* data) {
 static void reqBuddyWarp(CNSocket* sock, CNPacketData* data) {
     Player *plr = PlayerManager::getPlayer(sock);
 
-    sP_CL2FE_REQ_PC_BUDDY_WARP* pkt = (sP_CL2FE_REQ_PC_BUDDY_WARP*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_BUDDY_WARP*)data->buf;
 
     if (pkt->iSlotNum < 0 || pkt->iSlotNum >= 50)
         return; // sanity check
@@ -454,7 +454,7 @@ fail:
     INITSTRUCT(sP_FE2CL_REP_PC_BUDDY_WARP_FAIL, resp);
     resp.iBuddyPCUID = pkt->iBuddyPCUID;
     resp.iErrorCode = 0;
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_BUDDY_WARP_FAIL, sizeof(sP_FE2CL_REP_PC_BUDDY_WARP_FAIL));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_BUDDY_WARP_FAIL);
 }
 
 void Buddies::init() {
diff --git a/src/BuiltinCommands.cpp b/src/BuiltinCommands.cpp
index 4f0b8a0..44cf579 100644
--- a/src/BuiltinCommands.cpp
+++ b/src/BuiltinCommands.cpp
@@ -6,7 +6,7 @@
 
 // helper function, not a packet handler
 void BuiltinCommands::setSpecialState(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_GM_REQ_PC_SPECIAL_STATE_SWITCH* setData = (sP_CL2FE_GM_REQ_PC_SPECIAL_STATE_SWITCH*)data->buf;
+    auto setData = (sP_CL2FE_GM_REQ_PC_SPECIAL_STATE_SWITCH*)data->buf;
     Player *plr = PlayerManager::getPlayer(sock);
 
     // HACK: work around the invisible weapon bug
@@ -21,8 +21,8 @@ void BuiltinCommands::setSpecialState(CNSocket* sock, CNPacketData* data) {
     response.iReqSpecialStateFlag = setData->iSpecialStateFlag;
     response.iSpecialState = plr->iSpecialState;
 
-    sock->sendPacket((void*)&response, P_FE2CL_REP_PC_SPECIAL_STATE_SWITCH_SUCC, sizeof(sP_FE2CL_REP_PC_SPECIAL_STATE_SWITCH_SUCC));
-    PlayerManager::sendToViewable(sock, (void*)&response, P_FE2CL_PC_SPECIAL_STATE_CHANGE, sizeof(sP_FE2CL_PC_SPECIAL_STATE_CHANGE));
+    sock->sendPacket(response, P_FE2CL_REP_PC_SPECIAL_STATE_SWITCH_SUCC);
+    PlayerManager::sendToViewable(sock, response, P_FE2CL_PC_SPECIAL_STATE_CHANGE);
 }
 
 static void setGMSpecialSwitchPlayer(CNSocket* sock, CNPacketData* data) {
@@ -37,8 +37,7 @@ static void gotoPlayer(CNSocket* sock, CNPacketData* data) {
     if (plr->accountLevel > 50)
         return;
 
-    sP_CL2FE_REQ_PC_GOTO* gotoData = (sP_CL2FE_REQ_PC_GOTO*)data->buf;
-    INITSTRUCT(sP_FE2CL_REP_PC_GOTO_SUCC, response);
+    auto gotoData = (sP_CL2FE_REQ_PC_GOTO*)data->buf;
 
     DEBUGLOG(
         std::cout << "P_CL2FE_REQ_PC_GOTO:" << std::endl;
@@ -55,7 +54,7 @@ static void setValuePlayer(CNSocket* sock, CNPacketData* data) {
     if (plr->accountLevel > 50)
         return;
 
-    sP_CL2FE_GM_REQ_PC_SET_VALUE* setData = (sP_CL2FE_GM_REQ_PC_SET_VALUE*)data->buf;
+    auto setData = (sP_CL2FE_GM_REQ_PC_SET_VALUE*)data->buf;
 
     INITSTRUCT(sP_FE2CL_GM_REP_PC_SET_VALUE, response);
 
@@ -95,7 +94,7 @@ static void setValuePlayer(CNSocket* sock, CNPacketData* data) {
     response.iSetValue = setData->iSetValue;
     response.iSetValueType = setData->iSetValueType;
 
-    sock->sendPacket((void*)&response, P_FE2CL_GM_REP_PC_SET_VALUE, sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE));
+    sock->sendPacket(response, P_FE2CL_GM_REP_PC_SET_VALUE);
 
     // if one lowers their own health to 0, make sure others can see it
     if (plr->HP <= 0) {
@@ -105,7 +104,7 @@ static void setValuePlayer(CNSocket* sock, CNPacketData* data) {
         dead.iDamage = plr->HP;
         dead.iHP = plr->HP = 0;
 
-        PlayerManager::sendToViewable(sock, (void*)&dead, P_FE2CL_PC_SUDDEN_DEAD, sizeof(sP_FE2CL_PC_SUDDEN_DEAD));
+        PlayerManager::sendToViewable(sock, dead, P_FE2CL_PC_SUDDEN_DEAD);
     }
 }
 
@@ -116,12 +115,12 @@ static void setGMSpecialOnOff(CNSocket *sock, CNPacketData *data) {
     if (plr->accountLevel > 30)
         return;
 
-    sP_CL2FE_GM_REQ_TARGET_PC_SPECIAL_STATE_ONOFF *req = (sP_CL2FE_GM_REQ_TARGET_PC_SPECIAL_STATE_ONOFF*)data->buf;
+    auto req = (sP_CL2FE_GM_REQ_TARGET_PC_SPECIAL_STATE_ONOFF*)data->buf;
 
     CNSocket *otherSock = PlayerManager::getSockFromAny(req->eTargetSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
         AUTOU16TOU8(req->szTargetPC_FirstName), AUTOU16TOU8(req->szTargetPC_LastName));
     if (otherSock == nullptr) {
-        Chat::sendServerMessage(sock, "player to teleport not found");
+        Chat::sendServerMessage(sock, "player not found");
         return;
     }
 
@@ -141,7 +140,7 @@ static void locatePlayer(CNSocket *sock, CNPacketData *data) {
     if (plr->accountLevel > 30)
         return;
 
-    sP_CL2FE_GM_REQ_PC_LOCATION *req = (sP_CL2FE_GM_REQ_PC_LOCATION*)data->buf;
+    auto req = (sP_CL2FE_GM_REQ_PC_LOCATION*)data->buf;
 
     CNSocket *otherSock = PlayerManager::getSockFromAny(req->eTargetSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
         AUTOU16TOU8(req->szTargetPC_FirstName), AUTOU16TOU8(req->szTargetPC_LastName));
@@ -166,7 +165,7 @@ static void locatePlayer(CNSocket *sock, CNPacketData *data) {
     memcpy(resp.szTargetPC_FirstName, otherPlr->PCStyle.szFirstName, sizeof(resp.szTargetPC_FirstName));
     memcpy(resp.szTargetPC_LastName, otherPlr->PCStyle.szLastName, sizeof(resp.szTargetPC_LastName));
 
-    sock->sendPacket((void*)&resp, P_FE2CL_GM_REP_PC_LOCATION, sizeof(sP_FE2CL_GM_REP_PC_LOCATION));
+    sock->sendPacket(resp, P_FE2CL_GM_REP_PC_LOCATION);
 }
 
 static void kickPlayer(CNSocket *sock, CNPacketData *data) {
@@ -176,7 +175,7 @@ static void kickPlayer(CNSocket *sock, CNPacketData *data) {
     if (plr->accountLevel > 30)
         return;
 
-    sP_CL2FE_GM_REQ_KICK_PLAYER *req = (sP_CL2FE_GM_REQ_KICK_PLAYER*)data->buf;
+    auto req = (sP_CL2FE_GM_REQ_KICK_PLAYER*)data->buf;
 
     CNSocket *otherSock = PlayerManager::getSockFromAny(req->eTargetSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
         AUTOU16TOU8(req->szTargetPC_FirstName), AUTOU16TOU8(req->szTargetPC_LastName));
@@ -198,7 +197,7 @@ static void kickPlayer(CNSocket *sock, CNPacketData *data) {
     response.iExitCode = 3; // "a GM has terminated your connection"
 
     // send to target player
-    otherSock->sendPacket((void*)&response, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC));
+    otherSock->sendPacket(response, P_FE2CL_REP_PC_EXIT_SUCC);
 
     // ensure that the connection has terminated
     otherSock->kill();
@@ -211,7 +210,7 @@ static void warpToPlayer(CNSocket *sock, CNPacketData *data) {
     if (plr->accountLevel > 30)
         return;
 
-    sP_CL2FE_REQ_PC_WARP_TO_PC *req = (sP_CL2FE_REQ_PC_WARP_TO_PC*)data->buf;
+    auto req = (sP_CL2FE_REQ_PC_WARP_TO_PC*)data->buf;
 
     Player *otherPlr = PlayerManager::getPlayerFromID(req->iPC_ID);
     if (otherPlr == nullptr) {
@@ -230,7 +229,7 @@ static void teleportPlayer(CNSocket *sock, CNPacketData *data) {
     if (plr->accountLevel > 30)
         return;
 
-    sP_CL2FE_GM_REQ_TARGET_PC_TELEPORT *req = (sP_CL2FE_GM_REQ_TARGET_PC_TELEPORT*)data->buf;
+    auto req = (sP_CL2FE_GM_REQ_TARGET_PC_TELEPORT*)data->buf;
 
     // player to teleport
     CNSocket *targetSock = PlayerManager::getSockFromAny(req->eTargetPCSearchBy, req->iTargetPC_ID, req->iTargetPC_UID,
@@ -278,7 +277,7 @@ static void teleportPlayer(CNSocket *sock, CNPacketData *data) {
 }
 
 static void itemGMGiveHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_GIVE_ITEM* itemreq = (sP_CL2FE_REQ_PC_GIVE_ITEM*)data->buf;
+    auto itemreq = (sP_CL2FE_REQ_PC_GIVE_ITEM*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     if (plr->accountLevel > 50) {
@@ -288,7 +287,6 @@ static void itemGMGiveHandler(CNSocket* sock, CNPacketData* data) {
 
     if (itemreq->eIL == 2) {
         // 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 && itemreq->Item.iType >= 0 && itemreq->Item.iType <= 10) {
 
         if (Items::ItemData.find(std::pair<int32_t, int32_t>(itemreq->Item.iID, itemreq->Item.iType)) == Items::ItemData.end()) {
@@ -310,7 +308,7 @@ static void itemGMGiveHandler(CNSocket* sock, CNPacketData* data) {
 
         plr->Inven[itemreq->iSlotNum] = itemreq->Item;
 
-        sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC));
+        sock->sendPacket(resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC);
     }
 }
 
diff --git a/src/Chat.cpp b/src/Chat.cpp
index d354d1e..61b9803 100644
--- a/src/Chat.cpp
+++ b/src/Chat.cpp
@@ -10,7 +10,7 @@ std::vector<std::string> Chat::dump;
 using namespace Chat;
 
 static void chatHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_SEND_FREECHAT_MESSAGE* chat = (sP_CL2FE_REQ_SEND_FREECHAT_MESSAGE*)data->buf;
+    auto chat = (sP_CL2FE_REQ_SEND_FREECHAT_MESSAGE*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     std::string fullChat = sanitizeText(AUTOU16TOU8(chat->szFreeChat));
@@ -34,14 +34,14 @@ static void chatHandler(CNSocket* sock, CNPacketData* data) {
     resp.iPC_ID = 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));
+    sock->sendPacket(resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC);
 
     // send to visible players
-    PlayerManager::sendToViewable(sock, (void*)&resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC));
+    PlayerManager::sendToViewable(sock, resp, P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC);
 }
 
 static void menuChatHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE* chat = (sP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE*)data->buf;
+    auto chat = (sP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE*)data->buf;
     Player *plr = PlayerManager::getPlayer(sock);
 
     std::string fullChat = sanitizeText(AUTOU16TOU8(chat->szFreeChat));
@@ -57,24 +57,24 @@ static void menuChatHandler(CNSocket* sock, CNPacketData* data) {
     resp.iPC_ID = PlayerManager::getPlayer(sock)->iID;
     resp.iEmoteCode = chat->iEmoteCode;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC);
 
     // send to visible players
-    PlayerManager::sendToViewable(sock, (void*)&resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC));
+    PlayerManager::sendToViewable(sock, resp, P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC);
 }
 
 static void emoteHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT* emote = (sP_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT*)data->buf;
+    auto emote = (sP_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     // send to client
     INITSTRUCT(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, resp);
     resp.iEmoteCode = emote->iEmoteCode;
     resp.iID_From = plr->iID;
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT);
 
     // send to visible players (players within render distance)
-    PlayerManager::sendToViewable(sock, (void*)&resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT));
+    PlayerManager::sendToViewable(sock, resp, P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT);
 }
 
 void Chat::sendServerMessage(CNSocket* sock, std::string msg) {
@@ -85,14 +85,14 @@ void Chat::sendServerMessage(CNSocket* sock, std::string msg) {
     U8toU16(msg, (char16_t*)motd.szSystemMsg, sizeof(motd.szSystemMsg));
 
     // send the packet :)
-    sock->sendPacket((void*)&motd, P_FE2CL_PC_MOTD_LOGIN, sizeof(sP_FE2CL_PC_MOTD_LOGIN));
+    sock->sendPacket(motd, P_FE2CL_PC_MOTD_LOGIN);
 }
 
 static void announcementHandler(CNSocket* sock, CNPacketData* data) {
     Player* plr = PlayerManager::getPlayer(sock);
     if (plr->accountLevel > 30)
         return; // only players with account level less than 30 (GM) are allowed to use this command
-    sP_CL2FE_GM_REQ_PC_ANNOUNCE* announcement = (sP_CL2FE_GM_REQ_PC_ANNOUNCE*)data->buf;
+    auto announcement = (sP_CL2FE_GM_REQ_PC_ANNOUNCE*)data->buf;
 
     INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
     msg.iAnnounceType = announcement->iAnnounceType;
@@ -102,8 +102,8 @@ static void announcementHandler(CNSocket* sock, CNPacketData* data) {
 
     switch (announcement->iAreaType) {
     case 0: // area (all players in viewable chunks)
-        sock->sendPacket((void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE));
-        PlayerManager::sendToViewable(sock, (void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE));
+        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
+        PlayerManager::sendToViewable(sock, msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
         break;
     case 1: // shard
     case 2: // world
@@ -111,7 +111,7 @@ static void announcementHandler(CNSocket* sock, CNPacketData* data) {
     case 3: // global (all players)
         for (it = PlayerManager::players.begin(); it != PlayerManager::players.end(); it++) {
             CNSocket* allSock = it->first;
-            allSock->sendPacket((void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE));
+            allSock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
         }
     default:
         break;
@@ -124,7 +124,7 @@ static void announcementHandler(CNSocket* sock, CNPacketData* data) {
 
 // Buddy freechatting
 static void buddyChatHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_SEND_BUDDY_FREECHAT_MESSAGE* pkt = (sP_CL2FE_REQ_SEND_BUDDY_FREECHAT_MESSAGE*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_SEND_BUDDY_FREECHAT_MESSAGE*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     INITSTRUCT(sP_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC, resp);
@@ -156,13 +156,13 @@ static void buddyChatHandler(CNSocket* sock, CNPacketData* data) {
 
     U8toU16(fullChat, (char16_t*)&resp.szFreeChat, sizeof(resp.szFreeChat));
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC)); // confirm send to sender
-    otherSock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC)); // broadcast send to receiver
+    sock->sendPacket(resp, P_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC); // confirm send to sender
+    otherSock->sendPacket(resp, P_FE2CL_REP_SEND_BUDDY_FREECHAT_MESSAGE_SUCC); // broadcast send to receiver
 }
 
 // Buddy menuchat
 static void buddyMenuChatHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_SEND_BUDDY_MENUCHAT_MESSAGE* pkt = (sP_CL2FE_REQ_SEND_BUDDY_MENUCHAT_MESSAGE*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_SEND_BUDDY_MENUCHAT_MESSAGE*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     INITSTRUCT(sP_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC, resp);
@@ -186,12 +186,12 @@ static void buddyMenuChatHandler(CNSocket* sock, CNPacketData* data) {
 
     U8toU16(fullChat, (char16_t*)&resp.szFreeChat, sizeof(resp.szFreeChat));
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC)); // confirm send to sender
-    otherSock->sendPacket((void*)&resp, P_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC, sizeof(sP_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC)); // broadcast send to receiver
+    sock->sendPacket(resp, P_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC); // confirm send to sender
+    otherSock->sendPacket(resp, P_FE2CL_REP_SEND_BUDDY_MENUCHAT_MESSAGE_SUCC); // broadcast send to receiver
 }
 
 static void tradeChatHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_TRADE_EMOTES_CHAT* pacdat = (sP_CL2FE_REQ_PC_TRADE_EMOTES_CHAT*)data->buf;
+    auto pacdat = (sP_CL2FE_REQ_PC_TRADE_EMOTES_CHAT*)data->buf;
 
     CNSocket* otherSock; // weird flip flop because we need to know who the other player is
     if (pacdat->iID_Request == pacdat->iID_From)
@@ -218,8 +218,8 @@ static void tradeChatHandler(CNSocket* sock, CNPacketData* data) {
     dump.push_back(logLine);
 
     resp.iEmoteCode = pacdat->iEmoteCode;
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_TRADE_EMOTES_CHAT));
-    otherSock->sendPacket((void*)&resp, P_FE2CL_REP_PC_TRADE_EMOTES_CHAT, sizeof(sP_FE2CL_REP_PC_TRADE_EMOTES_CHAT));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_TRADE_EMOTES_CHAT);
+    otherSock->sendPacket(resp, P_FE2CL_REP_PC_TRADE_EMOTES_CHAT);
 }
 
 static void groupChatHandler(CNSocket* sock, CNPacketData* data) {
diff --git a/src/CustomCommands.cpp b/src/CustomCommands.cpp
index 4240519..2654f02 100644
--- a/src/CustomCommands.cpp
+++ b/src/CustomCommands.cpp
@@ -100,8 +100,8 @@ static void levelCommand(std::string full, std::vector<std::string>& args, CNSoc
     resp.iPC_ID = plr->iID;
     resp.iPC_Level = level;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_CHANGE_LEVEL, sizeof(sP_FE2CL_REP_PC_CHANGE_LEVEL));
-    PlayerManager::sendToViewable(sock, (void*)&resp, P_FE2CL_REP_PC_CHANGE_LEVEL, sizeof(sP_FE2CL_REP_PC_CHANGE_LEVEL));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_CHANGE_LEVEL);
+    PlayerManager::sendToViewable(sock, resp, P_FE2CL_REP_PC_CHANGE_LEVEL);
 }
 
 static void mssCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
@@ -357,7 +357,7 @@ static void npcRotateCommand(std::string full, std::vector<std::string>& args, C
     // update rotation clientside
     INITSTRUCT(sP_FE2CL_NPC_ENTER, pkt);
     pkt.NPCAppearanceData = npc->appearanceData;
-    sock->sendPacket((void*)&pkt, P_FE2CL_NPC_ENTER, sizeof(sP_FE2CL_NPC_ENTER));
+    sock->sendPacket(pkt, P_FE2CL_NPC_ENTER);
 }
 
 static void refreshCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
@@ -710,12 +710,12 @@ static void lairUnlockCommand(std::string full, std::vector<std::string>& args,
     Missions::startTask(plr, taskID);
     taskResp.iTaskNum = taskID;
     taskResp.iRemainTime = 0;
-    sock->sendPacket((void*)&taskResp, P_FE2CL_REP_PC_TASK_START_SUCC, sizeof(sP_FE2CL_REP_PC_TASK_START_SUCC));
+    sock->sendPacket(taskResp, P_FE2CL_REP_PC_TASK_START_SUCC);
 
     INITSTRUCT(sP_FE2CL_REP_PC_SET_CURRENT_MISSION_ID, missionResp);
     missionResp.iCurrentMissionID = missionID;
     plr->CurrentMissionID = missionID;
-    sock->sendPacket((void*)&missionResp, P_FE2CL_REP_PC_SET_CURRENT_MISSION_ID, sizeof(sP_FE2CL_REP_PC_SET_CURRENT_MISSION_ID));
+    sock->sendPacket(missionResp, P_FE2CL_REP_PC_SET_CURRENT_MISSION_ID);
 }
 
 static void hideCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
@@ -804,7 +804,7 @@ static void redeemCommand(std::string full, std::vector<std::string>& args, CNSo
         // save serverside
         plr->Inven[resp.iSlotNum] = resp.Item;
 
-        sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC));
+        sock->sendPacket(resp, P_FE2CL_REP_PC_GIVE_ITEM_SUCC);
     }
     std::string msg = itemCount == 1 ? "You have redeemed a code item" : "You have redeemed code items";
     Chat::sendServerMessage(sock, msg);
@@ -834,7 +834,7 @@ static void registerallCommand(std::string full, std::vector<std::string>& args,
     resp.aWyvernLocationFlag[0] = plr->aSkywayLocationFlag[0];
     resp.aWyvernLocationFlag[1] = plr->aSkywayLocationFlag[1];
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_SUCC, sizeof(sP_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_SUCC);
 }
 
 static void unregisterallCommand(std::string full, std::vector<std::string>& args, CNSocket* sock) {
@@ -851,7 +851,7 @@ static void unregisterallCommand(std::string full, std::vector<std::string>& arg
     resp.aWyvernLocationFlag[0] = plr->aSkywayLocationFlag[0];
     resp.aWyvernLocationFlag[1] = plr->aSkywayLocationFlag[1];
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_SUCC, sizeof(sP_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_REGIST_TRANSPORTATION_LOCATION_SUCC);
 }
 
 static void banCommand(std::string full, std::vector<std::string>& args, CNSocket *sock) {
@@ -903,7 +903,7 @@ static void banCommand(std::string full, std::vector<std::string>& args, CNSocke
     pkt.iExitCode = 3; // "a GM has terminated your connection"
 
     // send to target player
-    otherSock->sendPacket((void*)&pkt, P_FE2CL_REP_PC_EXIT_SUCC, sizeof(sP_FE2CL_REP_PC_EXIT_SUCC));
+    otherSock->sendPacket(pkt, P_FE2CL_REP_PC_EXIT_SUCC);
 
     // ensure that the connection has terminated
     otherSock->kill();
diff --git a/src/Email.cpp b/src/Email.cpp
index def0dce..59ef054 100644
--- a/src/Email.cpp
+++ b/src/Email.cpp
@@ -14,12 +14,12 @@ using namespace Email;
 static void emailUpdateCheck(CNSocket* sock, CNPacketData* data) {
     INITSTRUCT(sP_FE2CL_REP_PC_NEW_EMAIL, resp);
     resp.iNewEmailCnt = Database::getUnreadEmailCount(PlayerManager::getPlayer(sock)->iID);
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_NEW_EMAIL, sizeof(sP_FE2CL_REP_PC_NEW_EMAIL));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_NEW_EMAIL);
 }
 
 // Retrieve page of emails
 static void emailReceivePageList(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_RECV_EMAIL_PAGE_LIST* pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_PAGE_LIST*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_PAGE_LIST*)data->buf;
 
     INITSTRUCT(sP_FE2CL_REP_PC_RECV_EMAIL_PAGE_LIST_SUCC, resp);
     resp.iPageNum = pkt->iPageNum;
@@ -41,12 +41,12 @@ static void emailReceivePageList(CNSocket* sock, CNPacketData* data) {
         resp.aEmailInfo[i] = *emailInfo;
     }
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_RECV_EMAIL_PAGE_LIST_SUCC, sizeof(sP_FE2CL_REP_PC_RECV_EMAIL_PAGE_LIST_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_RECV_EMAIL_PAGE_LIST_SUCC);
 }
 
 // Read individual email
 static void emailRead(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_READ_EMAIL* pkt = (sP_CL2FE_REQ_PC_READ_EMAIL*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_READ_EMAIL*)data->buf;
 
     Player* plr = PlayerManager::getPlayer(sock);
 
@@ -63,12 +63,12 @@ static void emailRead(CNSocket* sock, CNPacketData* data) {
     }
     U8toU16(email.MsgBody, (char16_t*)resp.szContent, sizeof(resp.szContent));
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_READ_EMAIL_SUCC, sizeof(sP_FE2CL_REP_PC_READ_EMAIL_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_READ_EMAIL_SUCC);
 }
 
 // Retrieve attached taros from email
 static void emailReceiveTaros(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_RECV_EMAIL_CANDY* pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_CANDY*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_CANDY*)data->buf;
 
     Player* plr = PlayerManager::getPlayer(sock);
 
@@ -83,12 +83,12 @@ static void emailReceiveTaros(CNSocket* sock, CNPacketData* data) {
     resp.iCandy = plr->money;
     resp.iEmailIndex = pkt->iEmailIndex;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_RECV_EMAIL_CANDY_SUCC, sizeof(sP_FE2CL_REP_PC_RECV_EMAIL_CANDY_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_RECV_EMAIL_CANDY_SUCC);
 }
 
 // Retrieve individual attached item from email
 static void emailReceiveItemSingle(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_RECV_EMAIL_ITEM* pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_ITEM*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_ITEM*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     if (pkt->iSlotNum < 0 || pkt->iSlotNum >= AINVEN_COUNT || pkt->iSlotNum < 1 || pkt->iSlotNum > 4)
@@ -111,7 +111,7 @@ static void emailReceiveItemSingle(CNSocket* sock, CNPacketData* data) {
     resp.iEmailItemSlot = pkt->iEmailItemSlot;
     resp.iSlotNum = pkt->iSlotNum;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_RECV_EMAIL_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_RECV_EMAIL_ITEM_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_RECV_EMAIL_ITEM_SUCC);
 
     // update inventory
     INITSTRUCT(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC, resp2);
@@ -119,12 +119,12 @@ static void emailReceiveItemSingle(CNSocket* sock, CNPacketData* data) {
     resp2.iSlotNum = resp.iSlotNum;
     resp2.Item = itemTo;
 
-    sock->sendPacket((void*)&resp2, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC));
+    sock->sendPacket(resp2, P_FE2CL_REP_PC_GIVE_ITEM_SUCC);
 }
 
 // Retrieve all attached items from email
 static void emailReceiveItemAll(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_RECV_EMAIL_ITEM_ALL* pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_ITEM_ALL*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_RECV_EMAIL_ITEM_ALL*)data->buf;
 
     // move items to player inventory
     Player* plr = PlayerManager::getPlayer(sock);
@@ -152,7 +152,7 @@ static void emailReceiveItemAll(CNSocket* sock, CNPacketData* data) {
         resp2.iSlotNum = slot;
         resp2.Item = itemTo;
 
-        sock->sendPacket((void*)&resp2, P_FE2CL_REP_PC_GIVE_ITEM_SUCC, sizeof(sP_FE2CL_REP_PC_GIVE_ITEM_SUCC));
+        sock->sendPacket(resp2, P_FE2CL_REP_PC_GIVE_ITEM_SUCC);
     }
 
     // delete all items from db
@@ -161,12 +161,12 @@ static void emailReceiveItemAll(CNSocket* sock, CNPacketData* data) {
     INITSTRUCT(sP_FE2CL_REP_PC_RECV_EMAIL_ITEM_ALL_SUCC, resp);
     resp.iEmailIndex = pkt->iEmailIndex;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_RECV_EMAIL_ITEM_ALL_SUCC, sizeof(sP_FE2CL_REP_PC_RECV_EMAIL_ITEM_ALL_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_RECV_EMAIL_ITEM_ALL_SUCC);
 }
 
 // Delete an email
 static void emailDelete(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_DELETE_EMAIL* pkt = (sP_CL2FE_REQ_PC_DELETE_EMAIL*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_DELETE_EMAIL*)data->buf;
 
     Database::deleteEmails(PlayerManager::getPlayer(sock)->iID, pkt->iEmailIndexArray);
 
@@ -175,12 +175,12 @@ static void emailDelete(CNSocket* sock, CNPacketData* data) {
         resp.iEmailIndexArray[i] = pkt->iEmailIndexArray[i]; // i'm scared of memcpy
     }
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_DELETE_EMAIL_SUCC, sizeof(sP_FE2CL_REP_PC_DELETE_EMAIL_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_DELETE_EMAIL_SUCC);
 }
 
 // Send an email
 static void emailSend(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_SEND_EMAIL* pkt = (sP_CL2FE_REQ_PC_SEND_EMAIL*)data->buf;
+    auto pkt = (sP_CL2FE_REQ_PC_SEND_EMAIL*)data->buf;
     Player* plr = PlayerManager::getPlayer(sock);
 
     // sanity checks
@@ -220,7 +220,7 @@ static void emailSend(CNSocket* sock, CNPacketData* data) {
         INITSTRUCT(sP_FE2CL_REP_PC_SEND_EMAIL_FAIL, errResp);
         errResp.iErrorCode = 1;
         errResp.iTo_PCUID = pkt->iTo_PCUID;
-        sock->sendPacket((void*)&errResp, P_FE2CL_REP_PC_SEND_EMAIL_FAIL, sizeof(sP_FE2CL_REP_PC_SEND_EMAIL_FAIL));
+        sock->sendPacket(errResp, P_FE2CL_REP_PC_SEND_EMAIL_FAIL);
         return;
     }
 
@@ -235,7 +235,7 @@ static void emailSend(CNSocket* sock, CNPacketData* data) {
             INITSTRUCT(sP_FE2CL_REP_PC_SEND_EMAIL_FAIL, resp);
             resp.iErrorCode = 9; // error code 9 tells the player they can't send attachments across time
             resp.iTo_PCUID = pkt->iTo_PCUID;
-            sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_SEND_EMAIL_FAIL, sizeof(sP_FE2CL_REP_PC_SEND_EMAIL_FAIL));
+            sock->sendPacket(resp, P_FE2CL_REP_PC_SEND_EMAIL_FAIL);
             return;
         }
     }
@@ -289,7 +289,7 @@ static void emailSend(CNSocket* sock, CNPacketData* data) {
         INITSTRUCT(sP_FE2CL_REP_PC_SEND_EMAIL_FAIL, errResp);
         errResp.iErrorCode = 1;
         errResp.iTo_PCUID = pkt->iTo_PCUID;
-        sock->sendPacket((void*)&errResp, P_FE2CL_REP_PC_SEND_EMAIL_FAIL, sizeof(sP_FE2CL_REP_PC_SEND_EMAIL_FAIL));
+        sock->sendPacket(errResp, P_FE2CL_REP_PC_SEND_EMAIL_FAIL);
         return;
     }
 
@@ -298,12 +298,12 @@ static void emailSend(CNSocket* sock, CNPacketData* data) {
     tarosResp.iPC_ID = plr->iID;
     tarosResp.iSetValueType = 5;
     tarosResp.iSetValue = plr->money;
-    sock->sendPacket((void*)&tarosResp, P_FE2CL_GM_REP_PC_SET_VALUE, sizeof(sP_FE2CL_GM_REP_PC_SET_VALUE));
+    sock->sendPacket(tarosResp, P_FE2CL_GM_REP_PC_SET_VALUE);
 
     resp.iCandy = plr->money;
     resp.iTo_PCUID = pkt->iTo_PCUID;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_SEND_EMAIL_SUCC, sizeof(sP_FE2CL_REP_PC_SEND_EMAIL_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_SEND_EMAIL_SUCC);
 }
 
 void Email::init() {
diff --git a/src/Items.cpp b/src/Items.cpp
index 01e4636..9e7a9d6 100644
--- a/src/Items.cpp
+++ b/src/Items.cpp
@@ -66,15 +66,15 @@ static void nanoCapsuleHandler(CNSocket* sock, int slot, sItemBase *chest) {
     sock->sendPacket((void*)respbuf, P_FE2CL_REP_REWARD_ITEM, resplen);
 
     // transmit chest opening acknowledgement packet
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_ITEM_CHEST_OPEN_SUCC, sizeof(sP_FE2CL_REP_ITEM_CHEST_OPEN_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_ITEM_CHEST_OPEN_SUCC);
 
     // check if player doesn't already have this nano
     if (plr->Nanos[nanoId].iID != 0) {
         INITSTRUCT(sP_FE2CL_GM_REP_PC_ANNOUNCE, msg);
         msg.iDuringTime = 4;
-        std::string text = "You have already aquired this nano!";
+        std::string text = "You have already acquired this nano!";
         U8toU16(text, msg.szAnnounceMsg, sizeof(text));
-        sock->sendPacket((void*)&msg, P_FE2CL_GM_REP_PC_ANNOUNCE, sizeof(sP_FE2CL_GM_REP_PC_ANNOUNCE));
+        sock->sendPacket(msg, P_FE2CL_GM_REP_PC_ANNOUNCE);
         return;
     }
     Nanos::addNano(sock, nanoId, -1, false);
@@ -168,7 +168,7 @@ static int getItemSetId(Crate& crate, int crateId) {
 }
 
 static void itemMoveHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_ITEM_MOVE* itemmove = (sP_CL2FE_REQ_ITEM_MOVE*)data->buf;
+    auto itemmove = (sP_CL2FE_REQ_ITEM_MOVE*)data->buf;
     INITSTRUCT(sP_FE2CL_PC_ITEM_MOVE_SUCC, resp);
 
     Player* plr = PlayerManager::getPlayer(sock);
@@ -305,18 +305,18 @@ static void itemMoveHandler(CNSocket* sock, CNPacketData* data) {
             plr->iPCState = 0;
 
         // send equip event to other players
-        PlayerManager::sendToViewable(sock, (void*)&equipChange, P_FE2CL_PC_EQUIP_CHANGE, sizeof(sP_FE2CL_PC_EQUIP_CHANGE));
+        PlayerManager::sendToViewable(sock, equipChange, P_FE2CL_PC_EQUIP_CHANGE);
 
         // set equipment stats serverside
         setItemStats(plr);
     }
 
     // send response
-    sock->sendPacket((void*)&resp, P_FE2CL_PC_ITEM_MOVE_SUCC, sizeof(sP_FE2CL_PC_ITEM_MOVE_SUCC));
+    sock->sendPacket(resp, P_FE2CL_PC_ITEM_MOVE_SUCC);
 }
 
 static void itemDeleteHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_PC_ITEM_DELETE* itemdel = (sP_CL2FE_REQ_PC_ITEM_DELETE*)data->buf;
+    auto itemdel = (sP_CL2FE_REQ_PC_ITEM_DELETE*)data->buf;
     INITSTRUCT(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC, resp);
 
     Player* plr = PlayerManager::getPlayer(sock);
@@ -329,11 +329,11 @@ static void itemDeleteHandler(CNSocket* sock, CNPacketData* data) {
     plr->Inven[itemdel->iSlotNum].iType = 0;
     plr->Inven[itemdel->iSlotNum].iOpt = 0;
 
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_ITEM_DELETE_SUCC, sizeof(sP_FE2CL_REP_PC_ITEM_DELETE_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_ITEM_DELETE_SUCC);
 }
 
 static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
-    sP_CL2FE_REQ_ITEM_USE* request = (sP_CL2FE_REQ_ITEM_USE*)data->buf;
+    auto request = (sP_CL2FE_REQ_ITEM_USE*)data->buf;
     Player* player = PlayerManager::getPlayer(sock);
 
     if (request->iSlotNum < 0 || request->iSlotNum >= AINVEN_COUNT)
@@ -347,7 +347,7 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
     if (!(gumball.iOpt > 0 && gumball.iType == 7 && gumball.iID>=119 && gumball.iID<=121)) {
         std::cout << "[WARN] Gumball not found" << std::endl;
         INITSTRUCT(sP_FE2CL_REP_PC_ITEM_USE_FAIL, response);
-        sock->sendPacket((void*)&response, P_FE2CL_REP_PC_ITEM_USE_FAIL, sizeof(sP_FE2CL_REP_PC_ITEM_USE_FAIL));
+        sock->sendPacket(response, P_FE2CL_REP_PC_ITEM_USE_FAIL);
         return;
     }
 
@@ -358,7 +358,7 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
         (  gumball.iID == 121 && nanoStyle == 2))) {
         std::cout << "[WARN] Gumball type doesn't match nano type" << std::endl;
         INITSTRUCT(sP_FE2CL_REP_PC_ITEM_USE_FAIL, response);
-        sock->sendPacket((void*)&response, P_FE2CL_REP_PC_ITEM_USE_FAIL, sizeof(sP_FE2CL_REP_PC_ITEM_USE_FAIL));
+        sock->sendPacket(response, P_FE2CL_REP_PC_ITEM_USE_FAIL);
         return;
     }
 
@@ -402,7 +402,7 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
     pkt.eTBU = 1; // eTimeBuffUpdate
     pkt.eTBT = 1; // eTimeBuffType 1 means nano
     pkt.iConditionBitFlag = player->iConditionBitFlag |= value1;
-    sock->sendPacket((void*)&pkt, P_FE2CL_PC_BUFF_UPDATE, sizeof(sP_FE2CL_PC_BUFF_UPDATE));
+    sock->sendPacket(pkt, P_FE2CL_PC_BUFF_UPDATE);
 
     sock->sendPacket((void*)&respbuf, P_FE2CL_REP_PC_ITEM_USE_SUCC, resplen);
     // update inventory serverside
@@ -422,11 +422,11 @@ static void itemBankOpenHandler(CNSocket* sock, CNPacketData* data) {
         resp.aBank[i] = plr->Bank[i];
     }
     resp.iExtraBank = 1;
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_PC_BANK_OPEN_SUCC, sizeof(sP_FE2CL_REP_PC_BANK_OPEN_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_PC_BANK_OPEN_SUCC);
 }
 
 static void chestOpenHandler(CNSocket *sock, CNPacketData *data) {
-    sP_CL2FE_REQ_ITEM_CHEST_OPEN *pkt = (sP_CL2FE_REQ_ITEM_CHEST_OPEN *)data->buf;
+    auto pkt = (sP_CL2FE_REQ_ITEM_CHEST_OPEN *)data->buf;
 
     // sanity check
     if (pkt->eIL != 1 || pkt->iSlotNum < 0 || pkt->iSlotNum >= AINVEN_COUNT)
@@ -515,7 +515,7 @@ static void chestOpenHandler(CNSocket *sock, CNPacketData *data) {
 
     // transmit chest opening acknowledgement packet
     std::cout << "opening chest..." << std::endl;
-    sock->sendPacket((void*)&resp, P_FE2CL_REP_ITEM_CHEST_OPEN_SUCC, sizeof(sP_FE2CL_REP_ITEM_CHEST_OPEN_SUCC));
+    sock->sendPacket(resp, P_FE2CL_REP_ITEM_CHEST_OPEN_SUCC);
 }
 
 // TODO: use this in cleaned up Items
@@ -552,7 +552,7 @@ void Items::checkItemExpire(CNSocket* sock, Player* player) {
     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
-    sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM* packet = (sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM*)respbuf;
+    auto packet = (sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM*)respbuf;
     sTimeLimitItemDeleteInfo2CL* itemData = (sTimeLimitItemDeleteInfo2CL*)(respbuf + sizeof(sP_FE2CL_PC_DELETE_TIME_LIMIT_ITEM));
     memset(respbuf, 0, resplen);
 
@@ -603,7 +603,7 @@ void Items::updateEquips(CNSocket* sock, Player* plr) {
         resp.iEquipSlotNum = i;
         resp.EquipSlotItem = plr->Equip[i];
 
-        PlayerManager::sendToViewable(sock, (void*)&resp, P_FE2CL_PC_EQUIP_CHANGE, sizeof(sP_FE2CL_PC_EQUIP_CHANGE));
+        PlayerManager::sendToViewable(sock, resp, P_FE2CL_PC_EQUIP_CHANGE);
     }
 }