InvManager.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "InvManager.h"
#include "ItemStack.h"
#include "InventoryUtils.h"
#include "NetHandlerPlayClient.h"
#include "EnchantmentHelper.h"
#include "MovementUtils.h"
#include "GuiScreen.h"
#include "PotionUtils.h"
#include "BlockUtils.h"
#include "Container.h"
#include "Entity.h"

#include "Logger.h"

void InvManager::runModule()
{
    // 正在使用物品
    if (CEntityPlayer::isUsingItem())
        return;

    jobject screen = CGuiScreen::getInstance();

    // GUI 不符合要求
    if (screen != nullptr && !CGuiScreen::inChat() && !CGuiScreen::inInventory()
        && !CGuiScreen::inGameMenu())
    {
        return;
    }

    if (clock() - lastStart > delay) {
        jobject stack = getStackInSlot(weaponSlot);
        if (stack != nullptr && !isBestWeapon(stack)) {
            getBestWeapon();
        }
    }

    getBestPickaxe();
    getBestAxe();
    getBestShovel();
    dropItems();
    swapBlocks();
    getBestBow();

    moveArrows();
    moveFood();
}

bool InvManager::isBlacklistedItem(jobject stack)
{
    std::string name = jstring2string(CItem::getUnlocalizedName(CItemStack::getItem(stack)));

    for (const auto& blacklistItem : blacklistedItems) {
        if (name.find(blacklistItem) != std::string::npos) {
            return true;
        }
    }
    return false;
}

bool InvManager::isBadPotion(jobject stack)
{
    if (stack == nullptr || !CItemStack::isPotion(stack))
        return false;

    return PotionUtils::potionHasBadEffects(stack);
}

bool InvManager::isBadItem(jobject stack, int slot, bool stealing)
{
    //Logger::addInfo("isBadItem stage 0");

    jobject item = CItemStack::getItem(stack);

    std::string stackName = _strlwr((char*)jstring2string(CItemStack::getDisplayName(stack)).c_str()),
        ulName = jstring2string(CItem::getUnlocalizedName(item));

    for (const auto& serverItem : serverItemNames) {
        if (sequ(serverItem, stackName)) {
            return stealing;
        }
    }

    if (CItemStack::isBlock(stack)) {
        return !BlockUtils::goodBlockForBridge(ulName, false);
    }

    //Logger::addInfo("isBadItem stage 1");

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    if (stealing) {
        if (isBestWeapon(stack) || isBestAxe(stack) || isBestPickaxe(stack) || isBestBow(stack) || isBestShovel(stack)) {
            //Logger::addInfo("isBadItem stage 1.5");
            return false;
        }
        if (CItemStack::isArmor(stack)) {
            for (int type = 1; type < 5; type++) {
                jobject is = CSlot::getStack(CContainer::getSlot(invContainer, type + 4));

                if (is != nullptr) {
                    std::string typeStr = "";

                    switch (type) {
                    case 1:
                        typeStr = "helmet";
                        break;
                    case 2:
                        typeStr = "chestplate";
                        break;
                    case 3:
                        typeStr = "leggings";
                        break;
                    case 4:
                        typeStr = "boots";
                        break;
                    }

                    if (ulName.find(typeStr) != std::string::npos
                        && getProtScore(is) > getProtScore(stack)) 
                    {
                        continue;
                    }
                }
                if (isBestArmor(stack, type)) {
                    //Logger::addInfo("isBadItem stage 1.6");
                    return false;
                }
            }
        }
    }

    //Logger::addInfo("isBadItem stage 2");

    int weaponSlotR = weaponSlot + 35, pickaxeSlotR = pickaxeSlot + 35,
        axeSlotR = axeSlot + 35, shovelSlotR = shovelSlot + 35;

    if (stealing || (slot != weaponSlotR || !isBestWeapon(getStackInSlot(weaponSlot)))
        && (slot != pickaxeSlotR || !isBestPickaxe(getStackInSlot(pickaxeSlot)))
        && (slot != axeSlotR || !isBestAxe(getStackInSlot(axeSlot)))
        && (slot != shovelSlotR || !isBestShovel(getStackInSlot(shovelSlot)))) {

        if (!stealing && CItemStack::isArmor(stack)) {
            for (int type = 1; type < 5; type++) {

                jobject is = CSlot::getStack(CContainer::getSlot(invContainer, type + 4));

                if (is != nullptr && isBestArmor(is, type)) {
                    continue;
                }
                if (isBestArmor(stack, type)) {
                    //Logger::addInfo("isBadItem stage 2.5");
                    return false;
                }
            }
        }

        //Logger::addInfo("isBadItem stage 3");

        if ((CItemStack::ulNameIs(stack, "item.wheat")) 
            || CItemStack::ulNameIs(stack, "item.monsterPlacer")
            || (CItemStack::isFood(stack) && dropFood && !(CItemStack::isGapple(stack)))
            || (CItemStack::isPotion(stack) && isBadPotion(stack))) {
            //Logger::addInfo("isBadItem stage 4");
            return true;
        }
        else if (!(CItemStack::isSword(stack)) 
            && !(CItemStack::isTool(stack))
            && !(CItemStack::isHoe(stack)) 
            && !(CItemStack::isArmor(stack))) {

            //Logger::addInfo("isBadItem stage 5");
            if (dropArchery && (CItemStack::ulNameIs(stack, "item.bow") || CItemStack::ulNameIs(stack, "item.arrow"))) {
                return true;
            }
            else {
                return (dropShears && ulName.find("shears") != std::string::npos)
                    || CItemStack::ulNameIs(stack, "item.glassBottle")
                    || isBlacklistedItem(stack);
            }
        }
        return isBlacklistedItem(stack);
    }
    //Logger::addInfo("isBadItem stage 6");

    return false;
}

jobject InvManager::getStackInSlot(int hotbarIndex)
{
    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();
    return CSlot::getStack(CContainer::getSlot(invContainer, hotbarIndex + 35));
}


// 计算武器/工具的伤害分数，不止锋利附魔
float InvManager::getDamageScore(jobject stack)
{
    if (stack == nullptr || CItemStack::getItem(stack) == nullptr) 
        return 0.f;

    float damage = 0;
    jobject item = CItemStack::getItem(stack);

    //Logger::addInfo("getDamageScore: " + jstring2string(CItemStack::getDisplayName(stack)));

    if (CItemStack::isSword(stack)) {
        damage += CItemSword::getDamageVsEntity(item);
        //Logger::addInfo("getDamageScore=" + str(damage) + " (sword base)");
    }
    else if (CItemStack::isTool(stack)) {
        damage += CItem::getMaxDamage(item);
        //Logger::addInfo("getDamageScore=" + str(damage) + " (tool base)");
    }

    damage += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_SHARPNESS, stack) * 1.25F +
        CEnchantmentHelper::getEnchantmentLevel(ENCHANT_FIRE_ASPECT, stack) * 0.1F;

    //Logger::addInfo("getDamageScore=" + str(damage));

    return damage;
}

float InvManager::getBowScore(jobject stack)
{
    float score = 0;

    if (CItemStack::isBow(stack)) {

        //Logger::addInfo("getBowScore");

        // 力量
        score += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_POWER, stack);

        // 冲击
        score += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_PUNCH, stack) * 0.8F;

        // 火矢
        score += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_FLAME, stack) * 0.5F;

        // 耐久
        score += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_UNBREAKING, stack) * 0.1F;

    }
    return score;
}

float InvManager::getToolScore(jobject stack)
{
    float score = 0;
    jobject item = CItemStack::getItem(stack);

    if (CItemStack::isTool(stack)) {

        //Logger::addInfo("getToolScore");

        std::string name = _strlwr((char*) jstring2string(CItem::getUnlocalizedName(item)).c_str() );

        if (CItemStack::isPickaxe(stack)) {

            score = CItemTool::getStrVsBlock(stack, BlockUtils::getBlockInstance("stone")) 
                - (name.find("gold") != std::string::npos ? 5 : 0);
        }
        else if (CItemStack::isSpade(stack)) {

            score = CItemTool::getStrVsBlock(stack, BlockUtils::getBlockInstance("dirt")) 
                - (name.find("gold") != std::string::npos ? 5 : 0);
        }
        else {
            if (!(CItemStack::isAxe(stack))) return 1;

            score = CItemTool::getStrVsBlock(stack, BlockUtils::getBlockInstance("log")) 
                - (name.find("gold") != std::string::npos ? 5 : 0);
        }

        score += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_EFFICIENCY, stack) * 0.0075F;
        score += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_UNBREAKING, stack) / 100.F;
    }
    return score;
}


// 计算盔甲的保护分数，不止保护附魔
float InvManager::getProtScore(jobject stack)
{
    float prot = 0;

    if (CItemStack::isArmor(stack)) {

        //Logger::addInfo("getProtScore");

        jobject item = CItemStack::getItem(stack);

        prot += CItemArmor::getDamageReductionAmount(item)
            + ((100 - CItemArmor::getDamageReductionAmount(item)) 
                * CEnchantmentHelper::getEnchantmentLevel(ENCHANT_PROTECTION, stack)) * 0.0075F;

        prot += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_BLAST_PROTECTION, stack) / 100.F;
        prot += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_FIRE_PROTECTION, stack) / 100.F;
        prot += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_THORNS, stack) / 100.F;
        prot += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_UNBREAKING, stack) / 25.F;
        prot += CEnchantmentHelper::getEnchantmentLevel(ENCHANT_FEATHER_FALLING, stack) / 100.F;
    }

    return prot;
}

bool InvManager::isBestWeapon(jobject stack)
{
    if (stack == nullptr) return false;

    //Logger::addInfo("isBestWeapon");

    float damage = getDamageScore(stack);

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {

            //Logger::addInfo("check damage slot=" + str(i));

            jobject is2 = CSlot::getStack(slot);

            if (CItemStack::isSword(is2) && getDamageScore(is2) > damage) {
                return false;
            }
        }
    }
    return CItemStack::isSword(stack);
}

bool InvManager::isBestPickaxe(jobject stack)
{
    if (stack == nullptr) return false;

    if (!CItemStack::isPickaxe(stack))
        return false;

    //Logger::addInfo("isBestPickaxe");

    float value = getToolScore(stack);

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {
            jobject is2 = CSlot::getStack(slot);

            if (getToolScore(is2) > value && CItemStack::isPickaxe(is2)) {
                return false;
            }
        }
    }
    return true;
}
bool InvManager::isBestAxe(jobject stack)
{
    if (stack == nullptr) return false;

    if (!CItemStack::isAxe(stack))
        return false;

    //Logger::addInfo("isBestAxe");

    float value = getToolScore(stack);

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {
            jobject is2 = CSlot::getStack(slot);

            if (getToolScore(is2) > value && CItemStack::isAxe(is2)) {
                return false;
            }
        }
    }
    return true;
}
bool InvManager::isBestShovel(jobject stack)
{
    if (stack == nullptr) return false;

    if (!CItemStack::isSpade(stack))
        return false;

    //Logger::addInfo("isBestShovel");

    float value = getToolScore(stack);

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {
            jobject is2 = CSlot::getStack(slot);

            if (getToolScore(is2) > value && CItemStack::isSpade(is2)) {
                return false;
            }
        }
    }
    return true;
}
bool InvManager::isBestBow(jobject stack)
{
    if (stack == nullptr) return false;

    if (!CItemStack::isBow(stack))
        return false;

    //Logger::addInfo("isBestBow");

    float value = getBowScore(stack);

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {
            jobject is2 = CSlot::getStack(slot);

            if (getBowScore(is2) > value && CItemStack::isBow(is2)) {
                return false;
            }
        }
    }
    return true;
}

bool InvManager::isBestArmor(jobject stack, int type)
{
    std::string typeStr = "";

    switch (type) {
    case 1:
        typeStr = "helmet";
        break;
    case 2:
        typeStr = "chestplate";
        break;
    case 3:
        typeStr = "leggings";
        break;
    case 4:
        typeStr = "boots";
        break;
    }

    if (CItemStack::ulNameContains(stack, typeStr.c_str())) {

        //Logger::addInfo("isBestArmor");

        float prot = getProtScore(stack);
        jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

        for (int i = 5; i < 45; i++) {

            jobject slot = CContainer::getSlot(invContainer, i);

            if (CSlot::getHasStack(slot)) {

                jobject is = CSlot::getStack(slot);

                if (CItemStack::ulNameContains(is, typeStr.c_str()) && getProtScore(is) > prot) {
                    return false;
                }

            }
        }

        return true;
    }
    return false;
}

void InvManager::getBestWeapon()
{
    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject is = CSlot::getStack(CContainer::getSlot(invContainer, i));

        if (is != nullptr 
            && CItemStack::isSword(is) 
            && isBestWeapon(is)
            && getDamageScore(is) > 0) {

            swap(i, weaponSlot -  1);
            break;
        }
    }
}

void InvManager::getBestPickaxe()
{
    if (clock() - lastStart < delay) return;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {

            jobject is = CSlot::getStack(slot);

            if (isBestPickaxe(is) && !isBestWeapon(is)) {

                int desiredSlot = 35 + pickaxeSlot;
                if (i == desiredSlot) return;

                jobject slot2 = CContainer::getSlot(invContainer, desiredSlot);
                jobject is2 = CSlot::getStack(slot2);

                if (!CSlot::getHasStack(slot2) || !isBestPickaxe(is2)) {
                    swap(i, desiredSlot - 36);
                }
            }
        }
    }
}

void InvManager::getBestAxe()
{
    if (clock() - lastStart < delay) return;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {

            jobject is = CSlot::getStack(slot);

            if (isBestAxe(is) && !isBestWeapon(is)) {

                int desiredSlot = 35 + axeSlot;
                if (i == desiredSlot) return;

                jobject slot2 = CContainer::getSlot(invContainer, desiredSlot);
                jobject is2 = CSlot::getStack(slot2);

                if (!CSlot::getHasStack(slot2) || !isBestAxe(is2)) {
                    swap(i, desiredSlot - 36);
                }
            }
        }
    }
}

void InvManager::getBestShovel()
{
    if (clock() - lastStart < delay) return;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {

            jobject is = CSlot::getStack(slot);

            if (isBestShovel(is) && !isBestWeapon(is)) {

                int desiredSlot = 35 + shovelSlot;
                if (i == desiredSlot) return;

                jobject slot2 = CContainer::getSlot(invContainer, desiredSlot);
                jobject is2 = CSlot::getStack(slot2);

                if (!CSlot::getHasStack(slot2) || !isBestShovel(is2)) {
                    swap(i, desiredSlot - 36);
                }
            }
        }
    }
}

void InvManager::getBestBow()
{
    if (clock() - lastStart < delay) return;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {
        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {

            jobject is = CSlot::getStack(slot);

            if (!CItemStack::isBow(is))
                continue;
            else {
                bool nmd = false;
                std::string stackName = _strlwr((char*)jstring2string(CItemStack::getDisplayName(is)).c_str());

                for (const auto& serverItem : serverItemNames) {
                    if (sequ(serverItem, stackName)) {
                        nmd = true;
                        break;
                    }
                }

                if (nmd)
                    continue;
            }

            if (isBestBow(is) && !isBestWeapon(is)) {

                int desiredSlot = 35 + bowSlot;
                if (i == desiredSlot) return;

                jobject slot2 = CContainer::getSlot(invContainer, desiredSlot);
                jobject is2 = CSlot::getStack(slot2);

                if (!CSlot::getHasStack(slot2) || !isBestBow(is2)) {
                    swap(i, desiredSlot - 36);
                }
            }
        }
    }
}

void InvManager::dropItems()
{
    if (clock() - lastStart < delay) return;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {

        if (canContinue()) return;
        
        jobject is = CSlot::getStack(CContainer::getSlot(invContainer, i));

        if (is != nullptr && isBadItem(is, i, false)) {
            InventoryUtils::drop(i);
            lastStart = clock();
            break;
        }
    }
}

int InvManager::getMostBlocks()
{
    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();
    int stack = 0;

    jobject blockSlotStack = CSlot::getStack(CContainer::getSlot(invContainer, blockSlot + 35));
    if (blockSlotStack != nullptr && CItemStack::isBlock(blockSlotStack)) {

        std::string stackName = _strlwr((char*)jstring2string(CItemStack::getDisplayName(blockSlotStack)).c_str());
        std::string ulName = jstring2string(CItem::getUnlocalizedName(CItemStack::getItem(blockSlotStack)));

        if (BlockUtils::goodBlockForBridge(ulName, true))
            stack = CItemStack::getCount(blockSlotStack);
    }

    int biggestSlot = -1;

    

    for (int i = 9; i < 45; i++) {

        jobject is = CSlot::getStack(CContainer::getSlot(invContainer, i));

        if (is != nullptr && CItemStack::isBlock(is) 
            && CItemStack::getCount(is) > stack) {

            bool isServerItem = false;
            std::string stackName = _strlwr((char*)jstring2string(CItemStack::getDisplayName(is)).c_str());
            std::string ulName = jstring2string(CItem::getUnlocalizedName(CItemStack::getItem(is)));

            // 不适合搭路的方块，不要用
            if (!BlockUtils::goodBlockForBridge(ulName, true)) {
                continue;
            }

            for (const auto& serverItem : serverItemNames)
                if (sequ(stackName, serverItem)) {
                    isServerItem = true;
                    break;
                }

            if (!isServerItem)
            {
                stack = CItemStack::getCount(is);
                biggestSlot = i;
            }
            
        }
    }
    return biggestSlot;
}

void InvManager::swapBlocks()
{
    if (!doSwapBlocks || clock() - lastStart < delay) return;

    int mostBlocksSlot = getMostBlocks();
    int desiredSlot = blockSlot + 35;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    if (mostBlocksSlot != -1 && mostBlocksSlot != desiredSlot) {

        // only switch if the hotbar slot doesn't already have blocks of the same quantity to prevent an inf loop
        jobject dss = CContainer::getSlot(invContainer, desiredSlot);
        jobject dsis = CSlot::getStack(dss);

        if (!(dsis != nullptr
            && CItemStack::isBlock(dsis)
            && CItemStack::getCount(dsis) >= 
                 CItemStack::getCount(
                     CSlot::getStack(
                         CContainer::getSlot(invContainer, mostBlocksSlot))
            )))
        {
            bool isServerItem = false;
            std::string stackName = _strlwr((char*)jstring2string(CItemStack::getDisplayName(dsis)).c_str());
            std::string ulName = jstring2string(CItem::getUnlocalizedName(CItemStack::getItem(dsis)));

            // 不适合搭路的方块，不要放到指定格子上
            if (!BlockUtils::goodBlockForBridge(ulName, true)) {
                return;
            }

            for (const auto& serverItem : serverItemNames)
                if (sequ(stackName, serverItem)) {
                    isServerItem = true;
                    break;
                }

            if (!isServerItem)
                swap(mostBlocksSlot, desiredSlot - 36);
        }
    }
}

bool InvManager::canContinue()
{
    return (inventoryOnly && !CGuiScreen::inInventory())
        ||
        (onlyWhileNotMoving && MovementUtils::isMoving());
}

void InvManager::moveArrows()
{
    // 不让箭矢占用快捷栏空间
    if (dropArchery|| !moveArrows|| clock() - lastStart < delay) return;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 36; i < 45; i++) {

        jobject is = CSlot::getStack(CContainer::getSlot(invContainer, i));

        if (is != nullptr && CItemStack::ulNameIs(is, "item.arrow")) {

            for (int j = 0; j < 36; j++) {
                if (nullptr == CSlot::getStack(CContainer::getSlot(invContainer, j))) {
                    fakeOpen();
                    InventoryUtils::click(i, 0, true);
                    fakeClose();
                    lastStart = clock();
                    break;
                }
            }

        }
    }
}

void InvManager::moveFood()
{
    if (dropFood || clock() - lastStart < delay) return;

    jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

    for (int i = 9; i < 45; i++) {

        jobject slot = CContainer::getSlot(invContainer, i);

        if (CSlot::getHasStack(slot)) {
            jobject is = CSlot::getStack(slot);

            if (hasMostGapples(is)) {
                int desiredSlot = 35 + gappleSlot;

                if (i == desiredSlot) return;

                jobject slot2 = CContainer::getSlot(invContainer, desiredSlot);

                if (!CSlot::getHasStack(slot2)
                    || !hasMostGapples(CSlot::getStack(slot2))) {
                    swap(i, desiredSlot - 36);
                }
            }
        }
    }
}

// 判断是否有最多的金苹果
bool InvManager::hasMostGapples(jobject stack)
{
    if (!CItemStack::isGapple(stack)) {
        return false;
    }
    else {
        
        int value = CItemStack::getCount(stack);

        // 附魔金苹果优先
        if (CItemStack::isNotchApple(stack))
            value *= 10;

        jobject invContainer = InventoryUtils::getPlayerInventoryContainer();

        for (int i = 9; i < 45; i++) {
            jobject slot = CContainer::getSlot(invContainer, i);

            if (CSlot::getHasStack(slot)) {

                jobject is = CSlot::getStack(slot);
                int cnt = CItemStack::getCount(is);

                // 如果同为附魔金苹果则比数量
                if (CItemStack::isNotchApple(is)) {
                    cnt *= 10;
                }

                if (CItemStack::isGapple(is) && cnt > value) {
                    return false;
                }
            }
        }
        return true;
    }
}

// 交换两个格子的物品
void InvManager::swap(int slot, int hSlot) {

    fakeOpen();
    InventoryUtils::swap(slot, hSlot);
    fakeClose();

    lastStart = clock();
}

// 假装打开背包
void InvManager::fakeOpen()
{
    if (!isInvOpen) {
        lastStart = clock();
        if (!inventoryOnly && inventoryPackets)
        {
            //PacketUtils.sendPacketNoEvent(new C16PacketClientStatus(C16PacketClientStatus.EnumState.OPEN_INVENTORY_ACHIEVEMENT));
            jobject c16 = CNetHandlerPlayClient::newC16Packet(CLIENT_STATUS_OPEN_INVENTORY_ACHIEVEMENT);
            if (c16)
            {
                CNetworkManager::sendPacket(c16,true);
                ct.env->DeleteLocalRef(c16);
            }
        }
        isInvOpen = true;
    }
}

// 假装关闭背包
void InvManager::fakeClose()
{
    if (isInvOpen) {
        if (!inventoryOnly && inventoryPackets)
        {
            int windowId = CContainer::getWindowId(InventoryUtils::getPlayerInventoryContainer());
         
            //   PacketUtils.sendPacketNoEvent(new C0DPacketCloseWindow(mc.thePlayer.inventoryContainer.windowId));

            jobject c0d = CNetHandlerPlayClient::newC0DPacket(windowId);
            if (c0d)
            {
                CNetworkManager::sendPacket(c0d,true);
                ct.env->DeleteLocalRef(c0d);
            }
        }
        isInvOpen = false;
    }
}