bool CExchange::CheckSpace()
{
    const static INVENTORY_PAGE_COUNT = 4;
    const static INVENTORY_PAGE_SIZE = 45;

    static std::vector<CGrid*> s_grids;
    s_grids.resize(INVENTORY_PAGE_COUNT);

    for (int i = 0; i < INVENTORY_PAGE_COUNT; ++i)
    {
        s_grids[i] = new CGrid(5, 9);
    }

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

    int i;

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

        BYTE itemSize = item->GetSize();
        BYTE bPage = i / (INVENTORY_PAGE_SIZE)-1;

        s_grids[bPage]->Put(i - (INVENTORY_PAGE_SIZE * bPage), 1, itemSize);
    }

    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;

        BYTE itemSize = item->GetSize();

        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[wBasePos])
                {
                    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;
        }
        else
        {
            bool bFound = false;
            for (int j = 0; j < INVENTORY_PAGE_COUNT; ++j)
            {
                int iPos = s_grids[j]->FindBlank(1, itemSize);
                if (iPos >= 0) {
                    s_grids[j]->Put(iPos, 1, itemSize);
                    bFound = true;
                    break;
                }
            }
            if (bFound)
                continue;

            return false;  // No space left in inventory
        }
    }

    return true;
}