// This file is part of ClassicAPI. // // ClassicAPI is free software: you can redistribute it and/or modify it under the terms // of the GNU General Public License as published by the Free Software Foundation, either // version 3 of the License, or (at your option) any later version. // // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along with // ClassicAPI. If not, see . // `C_Container.SortBags()` — arrange the player's bags. // // Two phases, because every item move is a server round trip and the // second phase has to read slot contents the first phase changed. // // PHASE ONE consolidates partial stacks, and hands that entirely to the // server: one `CMSG_AUTOSTORE_BAG_ITEM` per redundant stack, which // merges into existing stacks of the same item and splits across several // of them when that is what fits. Nothing here computes what fits, so // nothing here needs an item's max stack size — which matters, because // that number is unavailable until the item's data has arrived from the // server, and a merge that sizes stacks first silently skips the ones it // could not size. // // PHASE TWO places items. It runs on the next `Bag::UpdateDelayed` — the // engine's own "a bag changed this frame" signal — so the merges are // settled before anything is read. It plans the whole layout up front // and then tracks each item's live position as swaps fire, rather than // re-reading a layout it is in the middle of mutating. Our swap is // fire-and-forget and sets no client-side item lock, so the whole batch // goes out in one frame. // // Neither phase may touch the Lua stack: phase two runs from a bag-update // callback, outside any Lua call, where the engine may have its own // values on the stack. Hence the `*From` senders and the direct invMgr // walk rather than `ResolveBag`. // // THE ORDERING IS OURS. Retail computes it in code we cannot read, and // its categories (per-bag assignment flags, expansion filters) have no // counterpart here, so this is a defensible order rather than a // reproduction of Blizzard's: hearthstone, gear by descending quality, // consumables, reagents, trade goods, quest items, everything else by // quality, junk last. Within a category, by item class, subclass, name, // then fuller stacks first. // // An item whose data has NOT arrived is pinned: left where it is, with // its slot withheld from the destination pool so nothing else is planned // into it. It cannot be ranked without a class, quality and name, and // guessing scatters it. A later call places it once the data lands. Phase // one is unaffected, since it needs only the item ID. #include "Game.h" #include "Offsets.h" #include "bag/UpdateDelayed.h" #include "cvar/Factory.h" #include "item/BagFamily.h" #include "item/CGItem.h" #include "item/ID.h" #include "item/Location.h" #include "item/Record.h" #include "item/Swap.h" #include "object/Resolve.h" #include "unit/Identity.h" #include #include #include namespace Container::SortBags { namespace { // The two sets this can arrange. Both go through the same snapshot, // comparator and placement; they differ only in how phase one merges // (see ConsolidateViaServer / ConsolidateLocally). constexpr int kInventoryBags[] = {0, 1, 2, 3, 4}; constexpr int kBankBags[] = {-1, 5, 6, 7, 8, 9, 10}; // Fill direction, persisted like every other engine setting: the cvar // carries it to Config.wtf and `GetCVar("sortBagsRightToLeft")` reads it, // so it survives a session the way the retail setting does. CVar::Factory::Handle g_rightToLeftCVar = nullptr; bool RightToLeft() { return CVar::Factory::GetInt(g_rightToLeftCVar, 0) != 0; } // The two containers a sort can be told to leave alone. An equipped bag // is excluded per-bag through its own `DisableAutoSort` slot flag; the // backpack and the main bank container have no such slot, so each gets // its own setting. Persisted as cvars for the same reason the fill // direction is. CVar::Factory::Handle g_backpackAutosortCVar = nullptr; CVar::Factory::Handle g_bankAutosortCVar = nullptr; bool BackpackAutosortDisabled() { return CVar::Factory::GetInt(g_backpackAutosortCVar, 0) != 0; } bool BankAutosortDisabled() { return CVar::Factory::GetInt(g_bankAutosortCVar, 0) != 0; } // Merge packets sent by the most recent phase one, reset per sort. int g_mergePackets = 0; // The source slots phase one asked the server to empty. Phase two counts // how many are still occupied when it runs: any at all means it is // planning against a half-merged snapshot, because the server's replies // did not all arrive in the bag update that woke it. struct SourceSlot { int bag, slot; }; std::vector g_mergeSources; // Item.dbc `m_class` values we rank on. Per-module codes, the way // `Item::BagFamily` keeps its own. constexpr uint32_t kClassConsumable = 0; constexpr uint32_t kClassWeapon = 2; constexpr uint32_t kClassArmor = 4; constexpr uint32_t kClassReagent = 5; constexpr uint32_t kClassTradeGoods = 7; constexpr uint32_t kClassQuest = 12; constexpr uint32_t kQualityPoor = 0; constexpr uint32_t kQualityUncommon = 2; constexpr uint32_t kQualityRare = 3; constexpr uint32_t kQualityEpic = 4; // Primary key. Lower sorts nearer the first slot. enum Category : uint8_t { kCatHearthstone = 0, kCatGearEpic, kCatGearRare, kCatGearUncommon, kCatGearPlain, kCatConsumable, kCatReagent, kCatTradeGoods, kCatQuest, kCatOtherEpic, kCatOtherRare, kCatOtherUncommon, kCatOtherPlain, kCatJunk, }; uint8_t CategoryFor(uint32_t itemID, uint32_t itemClass, uint32_t quality) { if (itemID == Offsets::HEARTHSTONE_ITEM_ID) return kCatHearthstone; if (quality == kQualityPoor) return kCatJunk; if (itemClass == kClassWeapon || itemClass == kClassArmor) { if (quality >= kQualityEpic) return kCatGearEpic; if (quality == kQualityRare) return kCatGearRare; if (quality == kQualityUncommon) return kCatGearUncommon; return kCatGearPlain; } if (itemClass == kClassConsumable) return kCatConsumable; if (itemClass == kClassReagent) return kCatReagent; if (itemClass == kClassTradeGoods) return kCatTradeGoods; if (itemClass == kClassQuest) return kCatQuest; if (quality >= kQualityEpic) return kCatOtherEpic; if (quality == kQualityRare) return kCatOtherRare; if (quality == kQualityUncommon) return kCatOtherUncommon; return kCatOtherPlain; } struct Entry { const void *item; // CGItem — stable across the swap batch int curBag, curSlot; // live position, updated as swaps fire // Destination, or unassigned. The unassigned sentinel is destSLOT, // never destBag: slots are 1-based so a negative one is impossible, // whereas bagID -1 is the main bank. Testing destBag < 0 here treats // every item bound for the main bank as unplaced and silently drops // its move. int destBag, destSlot; uint32_t itemID; uint32_t family; // the item's own bag family (0 = fits anywhere) uint32_t itemClass, subClass, count; const char *name; uint8_t category; }; struct Cell { int bag, slot; }; char Lower(char c) { return (c >= 'A' && c <= 'Z') ? static_cast(c - 'A' + 'a') : c; } // A missing name sorts after every present one. Substituting a // placeholder string instead (libbagsort uses "zzz") wedges the unnamed // item in among items actually named with those letters; this keeps it // deterministic and at the end. In practice a nameless item is pinned // before it reaches here, so this is the belt to that braces. int CompareNames(const char *a, const char *b) { if (a == b) return 0; if (a == nullptr) return 1; if (b == nullptr) return -1; for (size_t i = 0;; ++i) { const char ca = Lower(a[i]), cb = Lower(b[i]); if (ca != cb) return ca < cb ? -1 : 1; if (ca == '\0') return 0; } } bool Precedes(const Entry &a, const Entry &b) { if (a.category != b.category) return a.category < b.category; if (a.itemClass != b.itemClass) return a.itemClass < b.itemClass; if (a.subClass != b.subClass) return a.subClass < b.subClass; const int byName = CompareNames(a.name, b.name); if (byName != 0) return byName < 0; if (a.count != b.count) return a.count > b.count; // fuller stacks first return a.itemID < b.itemID; // total order, so the result is stable } // A bag's storage, addressed without Lua: the invMgr holding its GUID // array, the linear index its first slot sits at, and the family it // accepts. The backpack lives inside the player's own invMgr; bags 1..4 // each have one of their own. struct BagView { const uint8_t *invMgr; int firstLinear; int slotCount; uint32_t family; }; // The backpack and the main bank both live inside the player's own // invMgr, at different linear bases. Equipped bags and bank bags each // have an invMgr of their own, reached through the bag item. bool ViewForBag(int bagID, BagView *out) { if (bagID == 0) { auto *inv = Unit::Identity::PlayerInventoryManager(); if (inv == nullptr) return false; *out = {inv, Offsets::INVMGR_BACKPACK_FIRST_SLOT, Offsets::BACKPACK_NUM_SLOTS, 0}; return true; } if (bagID == -1) { auto *inv = Unit::Identity::PlayerInventoryManager(); if (inv == nullptr) return false; *out = {inv, Offsets::INVMGR_BANK_MAIN_FIRST_SLOT, Offsets::INVMGR_BANK_MAIN_LAST_SLOT - Offsets::INVMGR_BANK_MAIN_FIRST_SLOT + 1, 0}; return true; } // Resolve the bag item that owns the container. Bank bags resolve // only once the bank window has been opened this session, which is // the right gate: the server refuses bank moves without it anyway, // so a bank sort attempted with the bank closed finds no cells and // does nothing rather than firing moves that would all be rejected. int equipSlot = 0; if (bagID >= 1 && bagID <= 4) equipSlot = Offsets::INVSLOT_BAG1 + bagID - 1; else if (bagID >= 5 && bagID <= 10) equipSlot = Offsets::INVMGR_BANK_BAG_FIRST_SLOT + 1 + (bagID - 5); else return false; auto *bagItem = Item::Location::ResolveEquipmentSlot(equipSlot); if (bagItem == nullptr) return false; auto *bagInv = static_cast( Item::Location::ContainerInventory(bagItem)); if (bagInv == nullptr) return false; const int slots = static_cast( Game::Read(bagInv, Offsets::OFF_INVMGR_SLOT_COUNT)); if (slots <= 0) return false; // A specialty bag only accepts its own family, and Turtle leaves the // raw field empty on bags — `BitmaskForRecord` derives it from the // container subclass, so a quiver reports a family here rather than // reading as general-purpose. Shared with `C_Item.GetItemFamily`, so // a bag and the items it holds agree. uint32_t family = 0; const int bagItemID = Item::ID::FromCGItem(bagItem); if (bagItemID > 0) { auto *rec = Item::PeekRecord(static_cast(bagItemID)); if (rec != nullptr) family = Item::BagFamily::BitmaskForRecord(rec); } *out = {bagInv, 0, slots, family}; return true; } const uint8_t *ItemAt(const BagView &v, int slotIndex0) { auto *guids = *reinterpret_cast( v.invMgr + Offsets::OFF_INVMGR_GUID_ARRAY); if (guids == nullptr) return nullptr; const uint64_t guid = guids[v.firstLinear + slotIndex0]; if (guid == 0) return nullptr; return static_cast( Object::ByGuid(Offsets::TYPEMASK_ITEM, guid, "SortBags", 0)); } uint32_t StackCount(const uint8_t *item) { auto *fields = Item::ObjectFields(item); if (fields == nullptr) return 1; const uint32_t n = Game::Read(fields, Offsets::OFF_DESCRIPTOR_STACK_COUNT); return n == 0 ? 1 : n; } // --- phase one: ask the server to consolidate ------------------------------- // Returns true if any packet went out. Every stack after the first of // its item ID is offered to the server, which merges what fits and // rehomes the rest. // // When the item's record is cached we skip the ones that provably cannot // stack, purely to save a packet. When it is NOT cached we send anyway: // the alternative is silently skipping a merge we could not size, which // is the failure this whole design avoids. // One stack per group of the same item, as gathered for either merge. struct Stack { const uint8_t *item; int bag, slot; uint32_t count; }; struct Group { uint32_t itemID; uint32_t maxStack; // 0 when the item's data has not arrived std::vector stacks; }; // Collects every stackable item across `bags`, grouped by item ID. // `maxStack` is 0 for an item whose data has not arrived; the callers // differ in what they do about that. std::vector GatherGroups(const int *bags, int bagCount) { std::vector groups; for (int b = 0; b < bagCount; ++b) { const int bag = bags[b]; BagView view; if (!ViewForBag(bag, &view)) continue; for (int i = 0; i < view.slotCount; ++i) { const uint8_t *item = ItemAt(view, i); if (item == nullptr) continue; const int itemID = Item::ID::FromCGItem(item); if (itemID <= 0) continue; const uint32_t id = static_cast(itemID); uint32_t maxStack = 0; auto *rec = Item::PeekRecord(id); if (rec != nullptr) { maxStack = Game::Read(rec, Offsets::OFF_ITEMSTATS_STACKABLE); if (maxStack <= 1) continue; // cannot stack at all, so never a merge candidate } Group *group = nullptr; for (auto &candidate : groups) { if (candidate.itemID == id) { group = &candidate; break; } } if (group == nullptr) { groups.push_back({id, maxStack, {}}); group = &groups.back(); } group->stacks.push_back({item, bag, i + 1, StackCount(item)}); } } return groups; } // Why this is computed here rather than delegated to the server's own // autostore, which can merge a stack into several destinations for one // packet and would otherwise be cheaper: // // `CMSG_AUTOSTORE_BAG_ITEM` names its destination with a container byte, // and the only value the engine's builder will emit for "the player" is // `INVENTORY_SLOT_BAG_0` (255). Server-side that is NOT the search-every- // bag path — that one is `NULL_BAG` (0), which the builder cannot // express. 255 takes the specific-container branch, which searches the // keyring and the backpack and nothing else. So autostore can never // merge a stack in one equipped bag with a stack in another, which is // most of the real cases. // // Addressing both endpoints explicitly costs a packet per transfer // instead of per emptied source — occasionally one more, when a stack // has to be split across several destinations — and works everywhere. // Bank consolidation has to be computed here. `CMSG_AUTOSTORE_BANK_ITEM` // always CROSSES the inventory/bank boundary — a bank-sourced item // travels out to the bags — so there is no "find this a fuller stack // inside the bank" packet to delegate to. This is the one place the // protocol forces a client-side merge, and it carries the cost that // comes with that: it needs each item's max stack size, which is // unavailable until that item's data has arrived, so a stack we cannot // size is left alone. // // Two rolling pointers per item: stacks fullest-first, then poured from // the back into the front until they meet. bool Consolidate(const int *bags, int bagCount) { std::vector groups = GatherGroups(bags, bagCount); bool fired = false; for (auto &group : groups) { if (group.stacks.size() < 2) continue; // Pack fully, not just enough to free a slot: 9 and 2 with a cap // of 10 become 10 and 1, even though that still occupies two // slots. Topping stacks up is the point of consolidating. // // This settles after one pass and does not re-fire on the next // call, because a maximally packed group has every stack full // except the last — so `space == 0` walks `lo` straight up to // `hi` and nothing is sent. std::sort(group.stacks.begin(), group.stacks.end(), [](const Stack &a, const Stack &b) { return a.count > b.count; }); size_t lo = 0, hi = group.stacks.size() - 1; while (lo < hi) { const uint32_t space = group.maxStack - group.stacks[lo].count; if (space == 0) { ++lo; continue; } const bool wholeStack = space >= group.stacks[hi].count; const uint32_t moved = wholeStack ? group.stacks[hi].count : space; // Choose the packet from OUR model, never from the item's // live stack count. The whole batch goes out in one frame, // so no reply has arrived and every descriptor still holds // its original count while the model has moved on. Asking // the descriptor would send a split for what is really the // last of a stack, and the server rejects a split that would // empty its source ("Couldn't split those items"). const bool sent = wholeStack ? Item::Swap::ContainersFrom( group.stacks[hi].item, group.stacks[hi].bag, group.stacks[hi].slot, group.stacks[lo].bag, group.stacks[lo].slot) : Item::Swap::MoveCountFrom( group.stacks[hi].item, group.stacks[hi].bag, group.stacks[hi].slot, group.stacks[lo].bag, group.stacks[lo].slot, static_cast(moved)); if (sent) { fired = true; ++g_mergePackets; // Only a whole-stack transfer empties its source, and // `mergesPending` means "sources that should be empty by // now but are not". if (wholeStack) g_mergeSources.push_back( {group.stacks[hi].bag, group.stacks[hi].slot}); } group.stacks[lo].count += moved; group.stacks[hi].count -= moved; if (group.stacks[hi].count == 0) --hi; // that stack is gone else ++lo; // this one is full } } return fired; } // --- phase two: plan a layout and fire the swaps ---------------------------- // Counters from the most recent Place(), read back by // `_classicapi_SortBagsStats()`. They exist to tell apart the three ways // a pass can fail to converge: swaps the engine refused to send, items // the planner found no cell for, and a plan that was complete and fully // sent yet still left the bags unsorted (which would mean a swap did // something other than swap). struct Stats { int entries; int cells; int pinned; int planned; int unplanned; int swapsSent; int swapsFailed; int sameItemAvoided; int generalCells; // destination cells in general-purpose containers int specialtyCells; // cells confined to one bag family int familyItems; // items that want a specialty bag int mergesPending; // phase-one sources still occupied at plan time }; Stats g_lastRun{}; void Place(const int *bags, int bagCount) { Stats stats{}; std::vector items; std::vector general; // Vanilla items carry at most one family bit, so a flat list keyed by // family is enough — no bitmask intersection needed. struct FamilyPool { uint32_t family; std::vector cells; size_t next; }; std::vector specialty; for (int b = 0; b < bagCount; ++b) { const int bag = bags[b]; BagView view; if (!ViewForBag(bag, &view)) continue; for (int i = 0; i < view.slotCount; ++i) { const int slot = i + 1; const uint8_t *item = ItemAt(view, i); const uint8_t *rec = nullptr; int itemID = 0; if (item != nullptr) { itemID = Item::ID::FromCGItem(item); if (itemID > 0) rec = Item::PeekRecord(static_cast(itemID)); if (rec == nullptr) { ++stats.pinned; continue; // pinned: unrankable, and its slot is withheld } } if (view.family == 0) { general.push_back({bag, slot}); } else { FamilyPool *pool = nullptr; for (auto &p : specialty) { if (p.family == view.family) { pool = &p; break; } } if (pool == nullptr) { specialty.push_back({view.family, {}, 0}); pool = &specialty.back(); } pool->cells.push_back({bag, slot}); } if (item == nullptr) continue; // an empty slot contributes a cell and nothing else Entry e{}; e.item = item; e.curBag = bag; e.curSlot = slot; e.destBag = -1; e.destSlot = -1; e.itemID = static_cast(itemID); e.family = Item::BagFamily::BitmaskForRecord(rec); e.itemClass = Game::Read(rec, Offsets::OFF_ITEMSTATS_CLASS); e.subClass = Game::Read(rec, Offsets::OFF_ITEMSTATS_SUBCLASS); e.count = StackCount(item); e.name = *reinterpret_cast( rec + Offsets::OFF_ITEMSTATS_NAME); e.category = CategoryFor( e.itemID, e.itemClass, Game::Read(rec, Offsets::OFF_ITEMSTATS_QUALITY)); items.push_back(e); } } stats.entries = static_cast(items.size()); stats.generalCells = static_cast(general.size()); for (const auto &p : specialty) stats.specialtyCells += static_cast(p.cells.size()); stats.cells = stats.generalCells + stats.specialtyCells; for (const auto &e : items) if (e.family != 0) ++stats.familyItems; // Any source phase one asked the server to empty that is still // occupied means this snapshot predates some of the merges. for (const auto &src : g_mergeSources) { for (const auto &e : items) { if (e.curBag == src.bag && e.curSlot == src.slot) { ++stats.mergesPending; break; } } } if (items.empty()) { g_lastRun = stats; return; } std::sort(items.begin(), items.end(), Precedes); // Right-to-left is expressed entirely as reversed cell lists: the // passes below still fill from the "front" and the "far end", those // ends have just swapped which physical slot they mean. So the // sorted run starts at the last slot of the last bag and junk // collects at the first slot of the first, both flipping together. if (RightToLeft()) { std::reverse(general.begin(), general.end()); for (auto &p : specialty) std::reverse(p.cells.begin(), p.cells.end()); } // Forward pass for everything but junk: a matching specialty bag // first, overflowing into the general cells. Junk then fills the // general cells from the far end, so it collects away from the rest // and the two passes cannot claim the same cell. size_t genFront = 0; size_t genBack = general.size(); for (auto &e : items) { if (e.category == kCatJunk) continue; Cell *cell = nullptr; if (e.family != 0) { for (auto &p : specialty) { if (p.family == e.family && p.next < p.cells.size()) { cell = &p.cells[p.next++]; break; } } } if (cell == nullptr && genFront < genBack) cell = &general[genFront++]; if (cell == nullptr) continue; // nowhere left to put it; leave it where it is e.destBag = cell->bag; e.destSlot = cell->slot; } for (auto it = items.rbegin(); it != items.rend(); ++it) { if (it->category != kCatJunk) continue; if (genBack <= genFront) break; const Cell &cell = general[--genBack]; it->destBag = cell.bag; it->destSlot = cell.slot; } // NEVER plan a swap between two stacks of the same item. The server's // swap handler tries a MERGE first and only falls through to a real // swap if the merge is impossible: if the two counts fit one stack it // collapses them into a single slot, and if they do not it // redistributes the counts and leaves both items where they are. // Neither is a swap, so the bookkeeping below would be wrong from // that point on and every later move in the batch would compound it. // // Two stacks of one item are interchangeable, though, so this costs // nothing: within each same-item run, hand each destination cell to // whichever member already occupies it. The run is contiguous because // identical items agree on every key ahead of count. for (size_t i = 0; i < items.size();) { size_t j = i; while (j < items.size() && items[j].itemID == items[i].itemID) ++j; for (size_t m = i; m < j; ++m) { for (size_t n = i; n < j; ++n) { if (n == m) continue; // its own destination matching is just "home" if (items[n].destSlot < 0) continue; // unassigned; nothing to trade if (items[n].destBag == items[m].curBag && items[n].destSlot == items[m].curSlot) { std::swap(items[m].destBag, items[n].destBag); std::swap(items[m].destSlot, items[n].destSlot); ++stats.sameItemAvoided; break; // m now targets the slot it is already in } } } i = j; } // Fire the batch. Each entry carries its live position, so the plan // stays valid as slots shuffle and nothing re-reads the bags. The // occupant of a destination takes the mover's old slot, which is what // the engine's swap does anyway. for (auto &e : items) { if (e.destSlot < 0) { // see the sentinel note on Entry ++stats.unplanned; continue; } ++stats.planned; if (e.destBag == e.curBag && e.destSlot == e.curSlot) continue; Entry *occupant = nullptr; for (auto &o : items) { if (&o != &e && o.curBag == e.destBag && o.curSlot == e.destSlot) { occupant = &o; break; } } const int fromBag = e.curBag, fromSlot = e.curSlot; if (!Item::Swap::ContainersFrom(e.item, fromBag, fromSlot, e.destBag, e.destSlot)) { ++stats.swapsFailed; continue; } ++stats.swapsSent; e.curBag = e.destBag; e.curSlot = e.destSlot; if (occupant != nullptr) { occupant->curBag = fromBag; occupant->curSlot = fromSlot; } } g_lastRun = stats; } // --- sequencing ------------------------------------------------------------- enum Phase { kIdle, kAwaitingMerge }; Phase g_phase = kIdle; // Which set the in-flight sort is arranging, so the deferred placement // pass knows what to walk. Points at one of the two static lists, so // there is nothing to own or free. const int *g_activeBags = nullptr; int g_activeBagCount = 0; void OnBagUpdate() { if (g_phase != kAwaitingMerge) return; // Clear the phase BEFORE placing: the swaps we are about to fire will // signal this callback again next frame, and we must be idle by then // or the sort would restart forever. g_phase = kIdle; Place(g_activeBags, g_activeBagCount); } const Bag::UpdateDelayed::AutoSubscribe _bagSub{&OnBagUpdate}; // Shared entry point. Bags and bank differ only in the list. void StartSort(const int *bags, int bagCount) { if (g_phase != kIdle) return; // a sort is already in flight g_activeBags = bags; g_activeBagCount = bagCount; g_mergePackets = 0; g_mergeSources.clear(); if (Consolidate(bags, bagCount)) g_phase = kAwaitingMerge; // let the merges land, then place else Place(bags, bagCount); // nothing to merge; the layout reads clean } // `C_Container.SortBags()` / `C_Container.SortBankBags()` — no // arguments, no return, matching the modern signatures. Fire-and-forget: // the work spans at least two frames. A call while a sort is already in // flight is ignored rather than queued, so a held-down keybind cannot // stack them up — and neither can sorting bags and bank at once. // Runs a sort over `bags`, dropping `excluded` when its autosort setting // says to leave that container alone. Dropping a bag from the set is all // it takes: the snapshot, the comparator and the placement only ever see // the bags they are handed, so an excluded bag is neither read from nor // written to. void StartSortExcluding(const int *bags, int count, int excluded, bool excludeIt) { if (!excludeIt) { StartSort(bags, count); return; } std::vector kept; kept.reserve(static_cast(count)); for (int i = 0; i < count; ++i) { if (bags[i] != excluded) kept.push_back(bags[i]); } if (!kept.empty()) StartSort(kept.data(), static_cast(kept.size())); } int __fastcall Script_C_Container_SortBags(void * /*L*/) { StartSortExcluding(kInventoryBags, sizeof(kInventoryBags) / sizeof(kInventoryBags[0]), /*excluded*/ 0, BackpackAutosortDisabled()); return 0; } int __fastcall Script_C_Container_SortBankBags(void * /*L*/) { StartSortExcluding(kBankBags, sizeof(kBankBags) / sizeof(kBankBags[0]), /*excluded*/ -1, BankAutosortDisabled()); return 0; } // `_classicapi_SortBagsStats()` -> entries, cells, pinned, planned, // unplanned, swapsSent, swapsFailed, sameItemAvoided — from the last // placement pass. Diagnostic only; not part of the API surface. int __fastcall Script_SortBagsStats(void *L) { Game::Lua::PushNumber(L, g_lastRun.entries); Game::Lua::PushNumber(L, g_lastRun.cells); Game::Lua::PushNumber(L, g_lastRun.pinned); Game::Lua::PushNumber(L, g_lastRun.planned); Game::Lua::PushNumber(L, g_lastRun.unplanned); Game::Lua::PushNumber(L, g_lastRun.swapsSent); Game::Lua::PushNumber(L, g_lastRun.swapsFailed); Game::Lua::PushNumber(L, g_lastRun.sameItemAvoided); Game::Lua::PushNumber(L, g_lastRun.generalCells); Game::Lua::PushNumber(L, g_lastRun.specialtyCells); Game::Lua::PushNumber(L, g_lastRun.familyItems); Game::Lua::PushNumber(L, g_mergePackets); Game::Lua::PushNumber(L, g_lastRun.mergesPending); return 13; } // `_classicapi_SortBagsBags(which)` -> bagID, slotCount, family for each // bag that resolves in that set (0 = the inventory set, 1 = the bank // set). A bag that does not resolve is skipped entirely, so a missing ID // in the output is itself the answer. Diagnostic only. int __fastcall Script_SortBagsBags(void *L) { const bool bank = Game::Lua::IsNumber(L, 1) && static_cast(Game::Lua::ToNumber(L, 1)) == 1; const int *bags = bank ? kBankBags : kInventoryBags; const int count = bank ? sizeof(kBankBags) / sizeof(kBankBags[0]) : sizeof(kInventoryBags) / sizeof(kInventoryBags[0]); int pushed = 0; for (int b = 0; b < count; ++b) { BagView view; if (!ViewForBag(bags[b], &view)) continue; Game::Lua::PushNumber(L, bags[b]); Game::Lua::PushNumber(L, view.slotCount); Game::Lua::PushNumber(L, static_cast(view.family)); pushed += 3; } return pushed; } // `C_Container.SetSortBagsRightToLeft(enable)` — no return, matching the // modern signature. Takes effect on the next sort; it does not re-sort. int __fastcall Script_SetSortBagsRightToLeft(void *L) { CVar::Factory::SetInt(g_rightToLeftCVar, Game::Lua::ToBoolean(L, 1) != 0 ? 1 : 0); return 0; } // `C_Container.GetSortBagsRightToLeft()` -> isEnabled int __fastcall Script_GetSortBagsRightToLeft(void *L) { Game::Lua::PushBool(L, RightToLeft()); return 1; } // `C_Container.SetBackpackAutosortDisabled(disable)` / // `C_Container.SetBankAutosortDisabled(disable)` — keep that container // out of `SortBags` / `SortBankBags`. No return, matching the modern // signatures; the paired getters report the stored setting. int __fastcall Script_SetBackpackAutosortDisabled(void *L) { CVar::Factory::SetInt(g_backpackAutosortCVar, Game::Lua::ToBoolean(L, 1) != 0 ? 1 : 0); return 0; } int __fastcall Script_GetBackpackAutosortDisabled(void *L) { Game::Lua::PushBool(L, BackpackAutosortDisabled()); return 1; } int __fastcall Script_SetBankAutosortDisabled(void *L) { CVar::Factory::SetInt(g_bankAutosortCVar, Game::Lua::ToBoolean(L, 1) != 0 ? 1 : 0); return 0; } int __fastcall Script_GetBankAutosortDisabled(void *L) { Game::Lua::PushBool(L, BankAutosortDisabled()); return 1; } void RegisterLuaFunctions() { // Dedups by name, so re-registering each reload is harmless. g_rightToLeftCVar = CVar::Factory::Register("sortBagsRightToLeft", "0"); g_backpackAutosortCVar = CVar::Factory::Register("backpackAutosortDisabled", "0"); g_bankAutosortCVar = CVar::Factory::Register("bankAutosortDisabled", "0"); Game::Lua::RegisterTableFunction("C_Container", "SortBags", &Script_C_Container_SortBags); Game::Lua::RegisterTableFunction("C_Container", "SetSortBagsRightToLeft", &Script_SetSortBagsRightToLeft); Game::Lua::RegisterTableFunction("C_Container", "GetSortBagsRightToLeft", &Script_GetSortBagsRightToLeft); Game::Lua::RegisterTableFunction("C_Container", "SortBankBags", &Script_C_Container_SortBankBags); Game::Lua::RegisterTableFunction("C_Container", "SetBackpackAutosortDisabled", &Script_SetBackpackAutosortDisabled); Game::Lua::RegisterTableFunction("C_Container", "GetBackpackAutosortDisabled", &Script_GetBackpackAutosortDisabled); Game::Lua::RegisterTableFunction("C_Container", "SetBankAutosortDisabled", &Script_SetBankAutosortDisabled); Game::Lua::RegisterTableFunction("C_Container", "GetBankAutosortDisabled", &Script_GetBankAutosortDisabled); Game::Lua::RegisterGlobalFunction("_classicapi_SortBagsStats", &Script_SortBagsStats); Game::Lua::RegisterGlobalFunction("_classicapi_SortBagsBags", &Script_SortBagsBags); } const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace } // namespace Container::SortBags