Ek envanter problem

bool CExchange::CheckSpace()
{
    static CGrid s_grid1(INVENTORY_PAGE_COLUMN, INVENTORY_PAGE_ROW); // inven page 1
    static CGrid s_grid2(INVENTORY_PAGE_COLUMN, INVENTORY_PAGE_ROW); // inven page 2
#ifdef ENABLE_EXTEND_INVEN_SYSTEM
    static CGrid s_grid3(INVENTORY_PAGE_COLUMN, INVENTORY_PAGE_ROW); // inven page 3
    static CGrid s_grid4(INVENTORY_PAGE_COLUMN, INVENTORY_PAGE_ROW); // inven page 4
#endif
#ifdef ENABLE_SPLIT_INVENTORY_SYSTEM
    LPCHARACTER    me = GetOwner();
    static CGrid s_grid5(5, SKILL_BOOK_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid6(5, SKILL_BOOK_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid7(5, SKILL_BOOK_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid8(5, SKILL_BOOK_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid9(5, UPGRADE_ITEMS_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid10(5, UPGRADE_ITEMS_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid11(5, UPGRADE_ITEMS_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid12(5, UPGRADE_ITEMS_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid13(5, STONE_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid14(5, STONE_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid15(5, STONE_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid16(5, STONE_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid17(5, BOX_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid18(5, BOX_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid19(5, BOX_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid20(5, BOX_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid21(5, EFSUN_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid22(5, EFSUN_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid23(5, EFSUN_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid24(5, EFSUN_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid25(5, CICEK_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid26(5, CICEK_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid27(5, CICEK_INVENTORY_MAX_NUM / 5 / 4);
    static CGrid s_grid28(5, CICEK_INVENTORY_MAX_NUM / 5 / 4);
#endif


    s_grid1.Clear();
    s_grid2.Clear();
#ifdef ENABLE_EXTEND_INVEN_SYSTEM
    s_grid3.Clear();
    s_grid4.Clear();
#endif
#ifdef ENABLE_SPLIT_INVENTORY_SYSTEM
    s_grid5.Clear();
    s_grid6.Clear();
    s_grid7.Clear();
    s_grid8.Clear();
    s_grid9.Clear();
    s_grid10.Clear();
    s_grid11.Clear();
    s_grid12.Clear();
    s_grid13.Clear();
    s_grid14.Clear();
    s_grid15.Clear();
    s_grid16.Clear();
    s_grid17.Clear();
    s_grid18.Clear();
    s_grid19.Clear();
    s_grid20.Clear();
    s_grid21.Clear();
    s_grid22.Clear();
    s_grid23.Clear();
    s_grid24.Clear();
    s_grid25.Clear();
    s_grid26.Clear();
    s_grid27.Clear();
    s_grid28.Clear();
#endif

    LPCHARACTER    victim = GetCompany()->GetOwner();
    LPITEM item;

    int i;

    for (i = 0; i < INVENTORY_PAGE_SIZE*1; ++i)
    {
        if (!(item = victim->GetInventoryItem(i)))
            continue;

        s_grid1.Put(i, 1, item->GetSize());
    }
    for (i = INVENTORY_PAGE_SIZE*1; i < INVENTORY_PAGE_SIZE*2; ++i)
    {
        if (!(item = victim->GetInventoryItem(i)))
            continue;

        s_grid2.Put(i - INVENTORY_PAGE_SIZE*1, 1, item->GetSize());
    }
#ifdef ENABLE_EXTEND_INVEN_SYSTEM
    for (i = INVENTORY_PAGE_SIZE*2; i < INVENTORY_PAGE_SIZE*3; ++i)
    {
        if (!(item = victim->GetInventoryItem(i)))
            continue;

        s_grid3.Put(i - INVENTORY_PAGE_SIZE*2, 1, item->GetSize());
    }
    for (i = INVENTORY_PAGE_SIZE*3; i < INVENTORY_PAGE_SIZE*4; ++i)
    {
        if (!(item = victim->GetInventoryItem(i)))
            continue;

        s_grid4.Put(i - INVENTORY_PAGE_SIZE*3, 1, item->GetSize());
    }
#endif
#ifdef ENABLE_SPLIT_INVENTORY_SYSTEM
    int b;
    int v;
    int u;
    int r;
    int a;
    int l;
    const int perPageSkillBookSlotCount = 45;
    const int perPageUpgradeItemsSlotCount = 45;
    const int perPageStoneSlotCount = 45;
    const int perPageBoxSlotCount = 45;
    const int perPageEfsunSlotCount = 45;
    const int perPageCicekSlotCount = 45;
    for (b = 0; b < SKILL_BOOK_INVENTORY_MAX_NUM; ++b) {
        if (!(item = me->GetSkillBookInventoryItem(b)))
            continue;
       
        BYTE itemSize = item->GetSize();
           
        if (i < perPageSkillBookSlotCount) // Notice: This is adjusted for 3 Pages only!
            s_grid5.Put(i, 1, itemSize);
        else if (i < perPageSkillBookSlotCount * 2)
            s_grid6.Put(i - perPageSkillBookSlotCount, 1, itemSize);
        else if (i < perPageSkillBookSlotCount * 3)
            s_grid7.Put(i - perPageSkillBookSlotCount * 2, 1, itemSize);
        else if (i < perPageSkillBookSlotCount * 4)
            s_grid8.Put(i - perPageSkillBookSlotCount * 3, 1, itemSize);
    }
   
    for (v = 0; v < UPGRADE_ITEMS_INVENTORY_MAX_NUM; ++v) {
        if (!(item = me->GetUpgradeItemsInventoryItem(v)))
            continue;
       
        BYTE itemSize = item->GetSize();
       
        if (i < perPageUpgradeItemsSlotCount) // Notice: This is adjusted for 3 Pages only!
            s_grid9.Put(i, 1, itemSize);
        else if (i < perPageUpgradeItemsSlotCount * 2)
            s_grid10.Put(i - perPageUpgradeItemsSlotCount, 1, itemSize);
        else if (i < perPageUpgradeItemsSlotCount * 3)
            s_grid11.Put(i - perPageUpgradeItemsSlotCount * 2, 1, itemSize);
        else if (i < perPageUpgradeItemsSlotCount * 4)
            s_grid12.Put(i - perPageUpgradeItemsSlotCount * 3, 1, itemSize);
    }
   
    for (u = 0; u < STONE_INVENTORY_MAX_NUM; ++u) {
        if (!(item = me->GetStoneInventoryItem(u)))
            continue;
       
        BYTE itemSize = item->GetSize();
       
        if (i < perPageStoneSlotCount) // Notice: This is adjusted for 3 Pages only!
            s_grid13.Put(i, 1, itemSize);
        else if (i < perPageStoneSlotCount * 2)
            s_grid14.Put(i - perPageStoneSlotCount, 1, itemSize);
        else if (i < perPageStoneSlotCount * 3)
            s_grid15.Put(i - perPageStoneSlotCount * 2, 1, itemSize);
        else if (i < perPageStoneSlotCount * 4)
            s_grid16.Put(i - perPageStoneSlotCount * 3, 1, itemSize);
    }
   
    for (r = 0; r < BOX_INVENTORY_MAX_NUM; ++r) {
        if (!(item = me->GetBoxInventoryItem(r)))
            continue;
       
        BYTE itemSize = item->GetSize();
       
        if (i < perPageBoxSlotCount) // Notice: This is adjusted for 3 Pages only!
            s_grid17.Put(i, 1, itemSize);
        else if (i < perPageBoxSlotCount * 2)
            s_grid18.Put(i - perPageBoxSlotCount, 1, itemSize);
        else if (i < perPageBoxSlotCount * 3)
            s_grid19.Put(i - perPageBoxSlotCount * 2, 1, itemSize);
        else if (i < perPageBoxSlotCount * 4)
            s_grid20.Put(i - perPageBoxSlotCount * 3, 1, itemSize);
    }
   
    for (a = 0; a < EFSUN_INVENTORY_MAX_NUM; ++a) {
        if (!(item = me->GetEfsunInventoryItem(a)))
            continue;
       
        BYTE itemSize = item->GetSize();
       
        if (i < perPageEfsunSlotCount) // Notice: This is adjusted for 3 Pages only!
            s_grid21.Put(i, 1, itemSize);
        else if (i < perPageEfsunSlotCount * 2)
            s_grid22.Put(i - perPageEfsunSlotCount, 1, itemSize);
        else if (i < perPageEfsunSlotCount * 3)
            s_grid23.Put(i - perPageEfsunSlotCount * 2, 1, itemSize);
        else if (i < perPageEfsunSlotCount * 4)
            s_grid24.Put(i - perPageEfsunSlotCount * 3, 1, itemSize);
    }
   
    for (l = 0; l < CICEK_INVENTORY_MAX_NUM; ++l) {
        if (!(item = me->GetCicekInventoryItem(l)))
            continue;
       
        BYTE itemSize = item->GetSize();
       
        if (i < perPageCicekSlotCount) // Notice: This is adjusted for 3 Pages only!
            s_grid25.Put(i, 1, itemSize);
        else if (i < perPageCicekSlotCount * 2)
            s_grid26.Put(i - perPageCicekSlotCount, 1, itemSize);
        else if (i < perPageCicekSlotCount * 3)
            s_grid27.Put(i - perPageCicekSlotCount * 2, 1, itemSize);
        else if (i < perPageCicekSlotCount * 4)
            s_grid28.Put(i - perPageCicekSlotCount * 3, 1, itemSize);
    }
#endif

    static std::vector <WORD> s_vDSGrid(DRAGON_SOUL_INVENTORY_MAX_NUM);

    bool bDSInitialized = false;

    for (i = 0; i < EXCHANGE_ITEM_MAX_NUM; ++i)
    {
        if (!(item = m_apItems[i]))
            continue;

        if (item->IsDragonSoul())
        {
            if (!victim->DragonSoul_IsQualified())
            {
                return false;
            }

            if (!bDSInitialized)
            {
                bDSInitialized = true;
                victim->CopyDragonSoulItemGrid(s_vDSGrid);
            }

            bool bExistEmptySpace = false;
            WORD wBasePos = DSManager::instance().GetBasePosition(item);
            if (wBasePos >= DRAGON_SOUL_INVENTORY_MAX_NUM)
                return false;

            for (int i = 0; i < DRAGON_SOUL_BOX_SIZE; i++)
            {
                WORD wPos = wBasePos + i;
                if (0 == s_vDSGrid[wPos]) // @fixme159 (wBasePos to wPos)
                {
                    bool bEmpty = true;
                    for (int j = 1; j < item->GetSize(); j++)
                    {
                        if (s_vDSGrid[wPos + j * DRAGON_SOUL_BOX_COLUMN_NUM])
                        {
                            bEmpty = false;
                            break;
                        }
                    }
                    if (bEmpty)
                    {
                        for (int j = 0; j < item->GetSize(); j++)
                        {
                            s_vDSGrid[wPos + j * DRAGON_SOUL_BOX_COLUMN_NUM] =  wPos + 1;
                        }
                        bExistEmptySpace = true;
                        break;
                    }
                }
                if (bExistEmptySpace)
                    break;
            }
            if (!bExistEmptySpace)
                return false;
        }
#ifdef ENABLE_SPLIT_INVENTORY_SYSTEM
        else if (item->IsSkillBook())
        {
            BYTE itemSize = item->GetSize();
            int iPos = s_grid5.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid5.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid6.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid6.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid7.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid7.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid8.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid8.Put(iPos, 1, itemSize);
                continue;
            }
           
           
            return false;
        }
        else if (item->IsUpgradeItem())
        {
            BYTE itemSize = item->GetSize();
            int iPos = s_grid9.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid9.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid10.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid10.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid11.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid11.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid12.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid12.Put(iPos, 1, itemSize);
                continue;
            }
           
            return false;
        }
        else if (item->IsStone())
        {
            BYTE itemSize = item->GetSize();
            int iPos = s_grid13.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid13.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid14.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid14.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid15.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid15.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid16.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid16.Put(iPos, 1, itemSize);
                continue;
            }
           
            return false;
        }
        else if (item->IsBox())
        {
            BYTE itemSize = item->GetSize();
            int iPos = s_grid17.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid17.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid18.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid18.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid19.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid19.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid20.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid20.Put(iPos, 1, itemSize);
                continue;
            }
           
            return false;
        }
        else if (item->IsEfsun())
        {
            BYTE itemSize = item->GetSize();
            int iPos = s_grid21.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid21.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid22.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid22.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid23.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid23.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid24.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid24.Put(iPos, 1, itemSize);
                continue;
            }
           
            return false;
        }
        else if (item->IsCicek())
        {
            BYTE itemSize = item->GetSize();
            int iPos = s_grid25.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid25.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid26.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid26.Put(iPos, 1, itemSize);
                continue;
            }
           
            iPos = s_grid27.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid27.Put(iPos, 1, itemSize);
                continue;
            }

            iPos = s_grid28.FindBlank(1, itemSize);
            if (iPos >= 0) {
                s_grid28.Put(iPos, 1, itemSize);
                continue;
            }
           
            return false;
        }
#endif
        else
        {
            int iPos;

            if ((iPos = s_grid1.FindBlank(1, item->GetSize())) >= 0)
            {
                s_grid1.Put(iPos, 1, item->GetSize());
            }
            else if ((iPos = s_grid2.FindBlank(1, item->GetSize())) >= 0)
            {
                s_grid2.Put(iPos, 1, item->GetSize());
            }
#ifdef ENABLE_EXTEND_INVEN_SYSTEM
            else if ((iPos = s_grid3.FindBlank(1, item->GetSize())) >= 0)
            {
                s_grid3.Put(iPos, 1, item->GetSize());
            }
            else if ((iPos = s_grid4.FindBlank(1, item->GetSize())) >= 0)
            {
                s_grid4.Put(iPos, 1, item->GetSize());
            }
#endif
            else
                return false;
        }
    }

    return true;
}

bool CExchange::Accept(bool bAccept)
{
    if (m_bAccept == bAccept)
        return true;

    m_bAccept = bAccept;

    if (m_bAccept && GetCompany()->m_bAccept)
    {
        int    iItemCount;

        LPCHARACTER victim = GetCompany()->GetOwner();

        //PREVENT_PORTAL_AFTER_EXCHANGE
        GetOwner()->SetExchangeTime();
        victim->SetExchangeTime();
        //END_PREVENT_PORTAL_AFTER_EXCHANGE

        // @fixme150 BEGIN
        if (quest::CQuestManager::instance().GetPCForce(GetOwner()->GetPlayerID())->IsRunning() == true)
        {
            GetOwner()->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot trade if you're using quests"));
            victim->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot trade if the other part using quests"));
            goto EXCHANGE_END;
        }
        else if (quest::CQuestManager::instance().GetPCForce(victim->GetPlayerID())->IsRunning() == true)
        {
            victim->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot trade if you're using quests"));
            GetOwner()->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot trade if the other part using quests"));
            goto EXCHANGE_END;
        }
        // @fixme150 END

        if (!Check(&iItemCount))
        {
            GetOwner()->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈이 부족하거나 아이템이 제자리에 없습니다."));
            victim->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방의 돈이 부족하거나 아이템이 제자리에 없습니다."));
            goto EXCHANGE_END;
        }

        if (!CheckSpace())
        {
            GetOwner()->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방의 소지품에 빈 공간이 없습니다."));
            victim->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
            goto EXCHANGE_END;
        }

        if (!GetCompany()->Check(&iItemCount))
        {
            victim->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈이 부족하거나 아이템이 제자리에 없습니다."));
            GetOwner()->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방의 돈이 부족하거나 아이템이 제자리에 없습니다."));
            goto EXCHANGE_END;
        }

        if (!GetCompany()->CheckSpace())
        {
            victim->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방의 소지품에 빈 공간이 없습니다."));
            GetOwner()->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
            goto EXCHANGE_END;
        }

        if (db_clientdesc->GetSocket() == INVALID_SOCKET)
        {
            sys_err("Cannot use exchange feature while DB cache connection is dead.");
            victim->ChatPacket(CHAT_TYPE_INFO, "Unknown error");
            GetOwner()->ChatPacket(CHAT_TYPE_INFO, "Unknown error");
            goto EXCHANGE_END;
        }

        if (Done())
        {
            if (m_lGold)
                GetOwner()->Save();

#ifdef ENABLE_CHEQUE_SYSTEM
            if (m_lCheque)
                GetOwner()->Save();
#endif

            if (GetCompany()->Done())
            {
                if (GetCompany()->m_lGold)
                    victim->Save();

#ifdef ENABLE_CHEQUE_SYSTEM
                if (GetCompany()->m_lCheque)
                    victim->Save();
#endif

                // INTERNATIONAL_VERSION
                GetOwner()->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s 님과의 교환이 성사 되었습니다."), victim->GetName());
                victim->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s 님과의 교환이 성사 되었습니다."), GetOwner()->GetName());
                // END_OF_INTERNATIONAL_VERSION
            }
        }

EXCHANGE_END:
        Cancel();
        return false;
    }
    else
    {
        exchange_packet(GetOwner(), EXCHANGE_SUBHEADER_GC_ACCEPT, true, m_bAccept, NPOS, 0);
        exchange_packet(GetCompany()->GetOwner(), EXCHANGE_SUBHEADER_GC_ACCEPT, false, m_bAccept, NPOS, 0);
        return true;
    }
}

bool CExchange::Done()
{
    int        empty_pos, i;
    LPITEM    item;

    LPCHARACTER    victim = GetCompany()->GetOwner();

    for (i = 0; i < EXCHANGE_ITEM_MAX_NUM; ++i)
    {
        if (!(item = m_apItems[i]))
            continue;

        empty_pos = victim->GetEmptyInventoryEx(item);

        if (empty_pos < 0)
        {
            sys_err("Exchange::Done : Cannot find blank position in inventory %s <-> %s item %s",
                    m_pOwner->GetName(), victim->GetName(), item->GetName());
            continue;
        }

        assert(empty_pos >= 0);

        m_pOwner->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 255);

        item->RemoveFromCharacter();
       
        item->AddToCharacter(victim, TItemPos(item->GetWindowInventoryEx(), empty_pos));
       
        ITEM_MANAGER::instance().FlushDelayedSave(item);

        item->SetExchanging(false);
        {
            char exchange_buf[51];

            snprintf(exchange_buf, sizeof(exchange_buf), "%s %u %u", item->GetName(), GetOwner()->GetPlayerID(), item->GetCount());
            LogManager::instance().ItemLog(victim, item, "EXCHANGE_TAKE", exchange_buf);

            snprintf(exchange_buf, sizeof(exchange_buf), "%s %u %u", item->GetName(), victim->GetPlayerID(), item->GetCount());
            LogManager::instance().ItemLog(GetOwner(), item, "EXCHANGE_GIVE", exchange_buf);

            if (item->GetVnum() >= 80003 && item->GetVnum() <= 80007)
            {
                LogManager::instance().GoldBarLog(victim->GetPlayerID(), item->GetID(), EXCHANGE_TAKE, "");
                LogManager::instance().GoldBarLog(GetOwner()->GetPlayerID(), item->GetID(), EXCHANGE_GIVE, "");
            }
        }

        m_apItems[i] = NULL;
    }

    if (m_lGold)
    {
        GetOwner()->PointChange(POINT_GOLD, -m_lGold, true);
        victim->PointChange(POINT_GOLD, m_lGold, true);

        if (m_lGold > 1000)
        {
            char exchange_buf[51];
            snprintf(exchange_buf, sizeof(exchange_buf), "%u %s", GetOwner()->GetPlayerID(), GetOwner()->GetName());
            LogManager::instance().CharLog(victim, m_lGold, "EXCHANGE_GOLD_TAKE", exchange_buf);

            snprintf(exchange_buf, sizeof(exchange_buf), "%u %s", victim->GetPlayerID(), victim->GetName());
            LogManager::instance().CharLog(GetOwner(), m_lGold, "EXCHANGE_GOLD_GIVE", exchange_buf);
        }
    }

#ifdef ENABLE_CHEQUE_SYSTEM
    if (m_lCheque)
    {
        GetOwner()->PointChange(POINT_CHEQUE, -m_lCheque, true);
        victim->PointChange(POINT_CHEQUE, m_lCheque, true);
    }
#endif

    m_pGrid->Clear();
    return true;
}