Groundwork for nanocom boosters

* The item use handler now has a switch for multiple item types (currently gumballs, and a stub for boosters)
* All item types are now checked for expiration, not just vehicles

Author: CakeLancelot

src/Items.cpp

@@ -328,8 +328,8 @@ static void itemMoveHandler(CNSocket* sock, CNPacketData* data) {
               && !(fromItem->iType == 0 && itemmove->iToSlotNum == 7)
               && fromItem->iType != itemmove->iToSlotNum)
             return; // something other than a vehicle or a weapon in a non-matching slot
-        else if (itemmove->iToSlotNum >= AEQUIP_COUNT) // TODO: reject slots >= 9?
-            return; // invalid slot
+        else if (itemmove->iToSlotNum > 8)
+            return; // any slot higher than 8 is for a booster, and they can't be equipped via move packet
     }
 
     // save items to response
@@ -430,25 +430,14 @@ static void itemDeleteHandler(CNSocket* sock, CNPacketData* data) {
     sock->sendPacket(resp, P_FE2CL_REP_PC_ITEM_DELETE_SUCC);
 }
 
-static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
+static void useGumball(CNSocket* sock, CNPacketData* data) {
     auto request = (sP_CL2FE_REQ_ITEM_USE*)data->buf;
     Player* player = PlayerManager::getPlayer(sock);
 
-    if (request->iSlotNum < 0 || request->iSlotNum >= AINVEN_COUNT)
-        return; // sanity check
-
     // gumball can only be used from inventory, so we ignore eIL
     sItemBase gumball = player->Inven[request->iSlotNum];
     sNano nano = player->Nanos[player->equippedNanos[request->iNanoSlot]];
 
-    // sanity check, check if gumball exists
-    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(response, P_FE2CL_REP_PC_ITEM_USE_FAIL);
-        return;
-    }
-
     // sanity check, check if gumball type matches nano style
     int nanoStyle = Nanos::nanoStyle(nano.iID);
     if (!((gumball.iID == 119 && nanoStyle == 0) ||
@@ -472,11 +461,8 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
         return;
     }
 
-    if (gumball.iOpt == 0)
-        gumball = {};
-
-    uint8_t respbuf[CN_PACKET_BODY_SIZE];
-    memset(respbuf, 0, CN_PACKET_BODY_SIZE);
+    uint8_t respbuf[CN_PACKET_BUFFER_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));
@@ -515,6 +501,54 @@ static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
     player->Inven[resp->iSlotNum] = resp->RemainItem;
 }
 
+static void useNanocomBooster(CNSocket* sock, CNPacketData* data) {
+
+}
+
+static void itemUseHandler(CNSocket* sock, CNPacketData* data) {
+    auto request = (sP_CL2FE_REQ_ITEM_USE*)data->buf;
+    Player* player = PlayerManager::getPlayer(sock);
+
+    if (request->iSlotNum < 0 || request->iSlotNum >= AINVEN_COUNT)
+        return; // sanity check
+
+    sItemBase item = player->Inven[request->iSlotNum];
+
+    // sanity check, check the item exists and has correct iType
+    if (!(item.iOpt > 0 && item.iType == 7)) {
+        std::cout << "[WARN] General item not found" << std::endl;
+        INITSTRUCT(sP_FE2CL_REP_PC_ITEM_USE_FAIL, response);
+        sock->sendPacket(response, P_FE2CL_REP_PC_ITEM_USE_FAIL);
+        return;
+    }
+
+    /*
+     * TODO: In the XDT, there are subtypes for general-use items
+     * (m_pGeneralItemTable -> m_pItemData-> m_iItemType) that
+     * determine their behavior. It would be better to load these
+     * and use them in this switch, rather than hardcoding by IDs.
+     */
+
+    switch(item.iID) {
+    case 119:
+    case 120:
+    case 121:
+        useGumball(sock, data);
+        break;
+    case 153:
+    case 154:
+    case 155:
+    case 156:
+        useNanocomBooster(sock, data);
+        break;
+    default:
+        std::cout << "[INFO] General item "<< item.iID << " is unimplemented." << std::endl;
+        INITSTRUCT(sP_FE2CL_REP_PC_ITEM_USE_FAIL, response);
+        sock->sendPacket(response, P_FE2CL_REP_PC_ITEM_USE_FAIL);
+        break;
+    }
+}
+
 static void itemBankOpenHandler(CNSocket* sock, CNPacketData* data) {
     Player* plr = PlayerManager::getPlayer(sock);
 
@@ -633,14 +667,14 @@ Item* Items::getItemData(int32_t id, int32_t type) {
 }
 
 void Items::checkItemExpire(CNSocket* sock, Player* player) {
-    if (player->toRemoveVehicle.eIL == 0 && player->toRemoveVehicle.iSlotNum == 0)
+    if (player->expiringItem.eIL == 0 && player->expiringItem.iSlotNum == 0)
         return;
 
     /* prepare packet
     * yes, this is a varadic packet, however analyzing client behavior and code
     * it only checks takes the first item sent into account
     * yes, this is very stupid
-    * therefore, we delete all but 1 expired vehicle while loading player
+    * therefore, we delete all but 1 expired item while loading player
     * to delete the last one here so player gets a notification
     */
 
@@ -653,18 +687,18 @@ void Items::checkItemExpire(CNSocket* sock, Player* player) {
     memset(respbuf, 0, resplen);
 
     packet->iItemListCount = 1;
-    itemData->eIL = player->toRemoveVehicle.eIL;
-    itemData->iSlotNum = player->toRemoveVehicle.iSlotNum;
+    itemData->eIL = player->expiringItem.eIL;
+    itemData->iSlotNum = player->expiringItem.iSlotNum;
     sock->sendPacket((void*)&respbuf, P_FE2CL_PC_DELETE_TIME_LIMIT_ITEM, resplen);
 
     // delete serverside
-    if (player->toRemoveVehicle.eIL == 0)
-        memset(&player->Equip[8], 0, sizeof(sItemBase));
+    if (player->expiringItem.eIL == 0)
+        memset(&player->Equip[player->expiringItem.iSlotNum], 0, sizeof(sItemBase));
     else
-        memset(&player->Inven[player->toRemoveVehicle.iSlotNum], 0, sizeof(sItemBase));
+        memset(&player->Inven[player->expiringItem.iSlotNum], 0, sizeof(sItemBase));
 
-    player->toRemoveVehicle.eIL = 0;
-    player->toRemoveVehicle.iSlotNum = 0;
+    player->expiringItem.eIL = 0;
+    player->expiringItem.iSlotNum = 0;
 }
 
 void Items::setItemStats(Player* plr) {
@@ -857,7 +891,6 @@ void Items::giveMobDrop(CNSocket *sock, Mob* mob, const DropRoll& rolled, const
 void Items::init() {
     REGISTER_SHARD_PACKET(P_CL2FE_REQ_ITEM_MOVE, itemMoveHandler);
     REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_ITEM_DELETE, itemDeleteHandler);
-    // this one is for gumballs
     REGISTER_SHARD_PACKET(P_CL2FE_REQ_ITEM_USE, itemUseHandler);
     // Bank
     REGISTER_SHARD_PACKET(P_CL2FE_REQ_PC_BANK_OPEN, itemBankOpenHandler);

src/Player.hpp

@@ -65,7 +65,7 @@ struct Player : public Entity, public ICombatant {
     sItemBase QInven[AQINVEN_COUNT] = {};
     int32_t CurrentMissionID = 0;
 
-    sTimeLimitItemDeleteInfo2CL toRemoveVehicle = {};
+    sTimeLimitItemDeleteInfo2CL expiringItem = {};
 
     Group* group = nullptr;
 

src/PlayerManager.cpp

@@ -536,8 +536,8 @@ static void enterPlayerVehicle(CNSocket* sock, CNPacketData* data) {
 
         // check if vehicle didn't expire
         if (expired) {
-            plr->toRemoveVehicle.eIL = 0;
-            plr->toRemoveVehicle.iSlotNum = 8;
+            plr->expiringItem.eIL = 0;
+            plr->expiringItem.iSlotNum = 8;
             Items::checkItemExpire(sock, plr);
         }
     }

src/db/player.cpp

@@ -2,35 +2,37 @@
 
 // Loading and saving players to/from the DB
 
-static void removeExpiredVehicles(Player* player) {
+static void removeExpiredItems(Player* player) {
     int32_t currentTime = getTimestamp();
 
-    // if there are expired vehicles in bank just remove them silently
+    // if there are expired items in bank just remove them silently
     for (int i = 0; i < ABANK_COUNT; i++) {
-        if (player->Bank[i].iType == 10 && player->Bank[i].iTimeLimit < currentTime && player->Bank[i].iTimeLimit != 0) {
+        if (player->Bank[i].iTimeLimit < currentTime && player->Bank[i].iTimeLimit != 0) {
             memset(&player->Bank[i], 0, sizeof(sItemBase));
         }
     }
 
-    // we want to leave only 1 expired vehicle on player to delete it with the client packet
+    // we want to leave only 1 expired item on player to delete it with the client packet
     std::vector<sItemBase*> toRemove;
 
-    // equipped vehicle
-    if (player->Equip[8].iOpt > 0 && player->Equip[8].iTimeLimit < currentTime && player->Equip[8].iTimeLimit != 0) {
-        toRemove.push_back(&player->Equip[8]);
-        player->toRemoveVehicle.eIL = 0;
-        player->toRemoveVehicle.iSlotNum = 8;
+    // equipped items
+    for (int i = 0; i < AEQUIP_COUNT; i++) {
+        if (player->Equip[i].iOpt > 0 && player->Equip[i].iTimeLimit < currentTime && player->Equip[i].iTimeLimit != 0) {
+            toRemove.push_back(&player->Equip[i]);
+            player->expiringItem.eIL = 0;
+            player->expiringItem.iSlotNum = i;
+        }
     }
     // inventory
     for (int i = 0; i < AINVEN_COUNT; i++) {
-        if (player->Inven[i].iType == 10 && player->Inven[i].iTimeLimit < currentTime && player->Inven[i].iTimeLimit != 0) {
+        if (player->Inven[i].iTimeLimit < currentTime && player->Inven[i].iTimeLimit != 0) {
             toRemove.push_back(&player->Inven[i]);
-            player->toRemoveVehicle.eIL = 1;
-            player->toRemoveVehicle.iSlotNum = i;
+            player->expiringItem.eIL = 1;
+            player->expiringItem.iSlotNum = i;
         }
     }
 
-    // delete all but one vehicles, leave last one for ceremonial deletion
+    // delete all but one item, leave last one for ceremonial deletion
     for (int i = 0; i < (int)toRemove.size()-1; i++) {
         memset(toRemove[i], 0, sizeof(sItemBase));
     }
@@ -160,7 +162,7 @@ void Database::getPlayer(Player* plr, int id) {
 
     sqlite3_finalize(stmt);
 
-    removeExpiredVehicles(plr);
+    removeExpiredItems(plr);
 
     // get quest inventory
     sql = R"(