Welcome!

Join our community of MMO enthusiasts and game developers! By registering, you'll gain access to discussions on the latest developments in MMO server files and collaborate with like-minded individuals. Join us today and unlock the potential of MMO server development!

Join Today!

Tc & auction

xxradicaldxx

xxradicaldxx

Junior Spellweaver
Joined
Sep 12, 2014
Messages
119
Reaction score
34
TRADE CENTER & AUCTION dev

Today I was reviewing some parts that I could find in IE and I could find a code that several I think they wanted but that they will have to do the rest on their own.I publish it in this section for people who want to contribute something else in this code that I could find
Code: 
///////////////////////////////////////////////////////////////////////////////
// 2013-11-25 by jhseol&bckim, °Å·¡¼Ò - ÆÐŶ ¸®½Ãºê ÇÔ¼ö ±¸Çö
ProcessResult CFieldIOCPSocket::Process_FC_MARKET_BASE_INFO_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_BASE_INFO_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    m_nMarketRegistrationCount = 0;
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_BASE_INFO_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }

    // Àӽà 
    {
        INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_BASE_INFO_HEAD, T_FC_MARKET_BASE_INFO_HEADER, pSendHeadMsg, pSendHeadBuf);
        pSendHeadMsg->nSellingTime = MARKET_SELLING_MINUTES;
        SendAddData(pSendHeadBuf, MSG_SIZE(MSG_FC_MARKET_BASE_INFO_HEAD));
    }

    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( MARKET_PACKET_RECV_TICK_BUY_PAGE > GetTickCount() - m_nLatelyMarketPacketRecvTick_BuyPage )
    {
        SendErrorMessage(T_FC_MARKET_BASE_INFO_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_BuyPage = GetTickCount();

    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_BASE_INFO_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_BASE_INFO_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ¿øº» º¹»çÈÄ º¹»ç¿©ºÎ È®ÀÎ
    m_CopyMarketListPtr.clear();
    ms_pFieldIOCP->m_pMarketDataManager->CopyMarketList(&m_CopyMarketListPtr);
    if ( TRUE == m_CopyMarketListPtr.empty() )
    {
        SendErrorMessage(T_FC_MARKET_BASE_INFO_REQUEST, ERR_DB_NO_SUCH_DATA, 100);
        
        
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // »óÅ°ªÀÌ À¯¿äÇÑ °Íµé¸¸ ÃßÃâ
    ATUM_DATE_TIME tmCurrentTime(TRUE);
    MARKET_LIST tmMarketList;
    tmMarketList.reserve(m_CopyMarketListPtr.size());
    tmMarketList.clear();
    tmMarketList.assign(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end());
    m_CopyMarketListPtr.clear();
    // ÃßÃâ ÈÄ ½Ã°£º° ³»¸²Â÷¼ø Á¤·ÄÀ» ÇÇÇϱâ À§ÇØ µÚ¿¡¼­ºÎÅÍ °Ë»ö
    // m_nMarketRegistrationCount = 0;
    MARKET_ITR itr = tmMarketList.end();
    while (itr != tmMarketList.begin())
    {
        itr--;
        if ( MARKET_STATE_SELL == (*itr)->MarketState 
            && MARKET_SELLING_MINUTES > tmCurrentTime.GetTimeDiffTimeInMinutes((*itr)->RegistTime)
#ifdef SC_MARKET_NOT_USE_NORMAL_INFL
            && (*itr)->MarketItemInfl == m_character.InfluenceType        // 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )    // µ¿Àϼ¼·Â 
#endif
            )
        {
            m_CopyMarketListPtr.push_back((*itr));
        }
        if ( (*itr)->CharacterUID == m_character.CharacterUniqueNumber && MARKET_STATE_DELETE != (*itr)->MarketState )
        {
            m_nMarketRegistrationCount++;
        }
    }
    /* ==>> ¾Õ¿¡¼­ ºÎÅÍ °Ë»öÇÏ°Ô µÇ¸é ½Ã°£º° ³»¸²Â÷¼ø Á¤·Ä±îÁö ÇؾßÇÔÀ¸·Î ¸®½ºÅ©°¡ Å©´Ù ±×·¯¹Ç·Î ÁÖ¼®Ã³¸®
    for ( ; itr != tmMarketList.end() ; itr++ )
    {
        if ( MARKET_STATE_SELL == (*itr)->MarketState && MARKET_SELLING_HOURS > tmCurrentTime.GetTimeDiffTimeInHours((*itr)->RegistTime) )
        {
            MARKET_INFO tmMarketInfo((*itr));
            m_CopyMarketListPtr.push_back((*itr));
        }
    }
    ///////////////////////////////////////////////
    // µî·Ï½Ã°£ º°·ç Á¤·Ä
    // À§¿¡¼­ ¿ª¼øÀ¸·Î ÃßÃâÇϸé Á¤·ÄÇÒ ÇÊ¿ä°¡ ¾ø´Ù
    sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_TIME_DOWN());
    m_nLatelyMarketListSortingType = MARKET_SORT_TIME_DOWN;
    <<== ¿©±â±îÁö */

    ///////////////////////////////////////////////
    // ÃßÃâ°á°ú ¸®½ºÆ® È®ÀÎ
    int nCopyMarketListSize = m_CopyMarketListPtr.size();
    if ( 0 >= nCopyMarketListSize )
    {
        SendErrorMessage(T_FC_MARKET_BASE_INFO_REQUEST, ERR_DB_NO_SUCH_DATA, 101);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // °Ë»ö°á°ú º¸³»±â
    
    //SendAddMessageType(T_FC_MARKET_BASE_INFO_HEADER);
    //
    
//    typedef struct 
//    {
//        INT nSellingTime;
//    } MSG_FC_MARKET_BASE_INFO_HEAD;
    
//     INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_BASE_INFO_HEAD, T_FC_MARKET_BASE_INFO_HEADER, pSendHeadMsg, pSendHeadBuf);
//     pSendHeadMsg->nSellingTime = MARKET_SELLING_MINUTES;
//     SendAddData(pSendHeadBuf, MSG_SIZE(MSG_FC_MARKET_BASE_INFO_HEAD));
    //


    // Çì´õ´Â À§¿¡¼­ º¸³À´Ï´Ù.. 
    // °æ¸Å½Ã°£°ªÀ» 
    itr = m_CopyMarketListPtr.begin();
    for ( int i = 0 ; i < MARKET_VIEW_LIST_COUNT ; i++, itr++ )
    {
        if ( itr == m_CopyMarketListPtr.end() )    // Ç׸ñÀÌ 8°Ô ¹Ì¸¸À϶§ ÇØ´ç
        {
            break;
        }
        INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_BASE_INFO_OK, T_FC_MARKET_BASE_INFO_OK, pSendOKMsg, pSendOKBuf);
        MARKET_INFO tmMarket(*itr);
        memcpy(&pSendOKMsg->MarketInfo, &tmMarket, sizeof(pSendOKMsg->MarketInfo));
        SendAddData(pSendOKBuf, MSG_SIZE(MSG_FC_MARKET_BASE_INFO_OK));
    }
    INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_BASE_INFO_DONE, T_FC_MARKET_BASE_INFO_DONE, pSendDoneMsg, pSendDoneBuf);
    pSendDoneMsg->ItemCount = nCopyMarketListSize;
    pSendDoneMsg->MaxPage = (nCopyMarketListSize / MARKET_VIEW_LIST_COUNT) + (0 == (nCopyMarketListSize % MARKET_VIEW_LIST_COUNT) ? 0 : 1);
    pSendDoneMsg->CurrentPage = 1;
    SendAddData(pSendDoneBuf, MSG_SIZE(MSG_FC_MARKET_BASE_INFO_DONE));
    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_MARKET_SEARCH_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_SEARCH_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_MARKET_SEARCH_REQUEST,
        MSG_FC_MARKET_SEARCH_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_SEARCH_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( MARKET_PACKET_RECV_TICK_BUY_PAGE > GetTickCount() - m_nLatelyMarketPacketRecvTick_BuyPage )
    {
        SendErrorMessage(T_FC_MARKET_SEARCH_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_BuyPage = GetTickCount();

    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_SEARCH_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_SEARCH_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ¿øº» º¹»çÈÄ º¹»ç¿©ºÎ È®ÀÎ
    m_CopyMarketListPtr.clear();
    ms_pFieldIOCP->m_pMarketDataManager->CopyMarketList(&m_CopyMarketListPtr);
    if ( TRUE == m_CopyMarketListPtr.empty() )
    {
        SendErrorMessage(T_FC_MARKET_SEARCH_REQUEST, ERR_DB_NO_SUCH_DATA, 100);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ÀÏ°ý °Ë»ö push_backÀÇ ¸®½ºÅ©¸¦ ÁÙÀ̱â À§ÇØ Çѹ濡 ¸ðµçÁ¶°ÇÀ» °Ë»ö!!
    ATUM_DATE_TIME tmCurrentTime(TRUE);
    MARKET_LIST tmMarketList;
    tmMarketList.reserve(m_CopyMarketListPtr.size());
    tmMarketList.clear();
    tmMarketList.assign(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end());
    m_CopyMarketListPtr.clear();
    MARKET_ITR itr = tmMarketList.begin();
    for ( ; itr != tmMarketList.end() ; itr++ )
    {
#ifdef SC_MARKET_NOT_USE_NORMAL_INFL
        if ( (*itr)->MarketItemInfl == m_character.InfluenceType )        // 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )    // µ¿Àϼ¼·Â                      
#endif
        {
            
        if ( pRMsg->MoneyType == (*itr)->MoneyType
            && MARKET_STATE_SELL == (*itr)->MarketState
            && MARKET_SELLING_MINUTES > tmCurrentTime.GetTimeDiffTimeInMinutes((*itr)->RegistTime)    
            && ( 0 == pRMsg->Kind        || IsMarketItemKindSame(pRMsg->Kind, (*itr)->ItemKind) )
            && ( 0 == pRMsg->ItemGear    || IS_SAME_UNITKIND(pRMsg->ItemGear, (*itr)->ItemGear) )
            && ( 0 == pRMsg->LevelMin    || pRMsg->LevelMin <= (*itr)->ItemLevel )
            && ( 0 == pRMsg->LevelMax    || pRMsg->LevelMax >= (*itr)->ItemLevel )
            && ( 0 == pRMsg->EnchantMin    || pRMsg->EnchantMin <= (*itr)->EnchantCount )
            && ( 0 == pRMsg->EnchantMax    || pRMsg->EnchantMax >= (*itr)->EnchantCount )
            )
        {
            if ( 0 < strlen(pRMsg->Name) )    // °Ë»ö¾î°¡ ÀÖÀ»°æ¿ì
            {
                char *token;
                char seps[] = " ";
                char buffer[MARKET_ITEM_FULL_NAME];
                
                STRNCPY_MEMSET(buffer, pRMsg->Name, MARKET_ITEM_FULL_NAME);
                token = strtok(buffer, seps);
                if( NULL != token )
                {
                    BYTE nFindNameIndex = 0;
                    nFindNameIndex = SearchWord((*itr)->ItemName, token, nFindNameIndex);    // 1. ¾ÆÀÌÅÛ ÀÌºí¿¡¼­ °Ë»öÇØ¾ß ÇÒ Ã¹¹ø° ´Ü¾î¸¦ ã´Â´Ù
                    while ( 0 < nFindNameIndex )            // 2. ´Ü¾î°¡ Æ÷ÇÔµÇÁö ¾ÊÀ¸¸é nFindNameIndex °¡ 0°ªÀ» °¡ÁüÀ¸·Î ¹Ýº¹¹®ÀÌ ¼öÇàµÇÁö ¾È´Â´Ù.
                    {
                        token = strtok(NULL, seps);            // 3. ±×·¸Áö ¾Ê°í ´Ü¾î°¡ Æ÷ÇԵǾî ÀÖÀ¸¸é ÀÔ·ÂÇÑ °Ë»ö¾î Áß ´õ ã¾Æ¾ß ºÁ¾ßÇÏ´Â ´ÙÀ½ ´Ü¾î°¡ ÀÖ´ÂÁö È®ÀÎÇÏ°í
                        if ( NULL == token )                // 4. ´õÀÌ»ó ãÀ» ´Ü¾î°¡ ¾ø´Ù¸é °Ë»öÇؾßÇÒ ¸ðµç ´Ü¾î°¡ Æ÷ÇÔµÈ ¾ÆÀÌÅÛ À̹ǷΠpush_back
                        {
                            m_CopyMarketListPtr.push_back((*itr));    
                            nFindNameIndex = 0;                // 5. ¹Ýº¹¹® Å»ÃâÁ¶°ÇÀÎ nFindNameIndex ¿¡ 0°ªÀ» ¼ÂÆÃ
                        }
                        else                                // 6. ¶Ç ã¾Æ¾ß ÇÏ´Â ´Ü¾î°¡ ÀÖ´Ù¸é
                        {
                            nFindNameIndex = SearchWord((*itr)->ItemName, token, nFindNameIndex);    // 7. ´Ü¾î¸¦ ã°í 2¹øºÎÅÍ ¹Ýº¹
                        }
                    }
                }
            }
            else    // °Ë»ö¾î°¡ ¾øÀ» °æ¿ì ¹Ù·Î push_back
            {
                m_CopyMarketListPtr.push_back((*itr));
            }
        }
        }    // 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )    // µ¿Àϼ¼·Â                      
    }

    ///////////////////////////////////////////////
    // °Ë»ö°á°ú ¸®½ºÆ® È®ÀÎ
    int nCopyMarketListSize = m_CopyMarketListPtr.size();
//     if ( 0 >= nCopyMarketListSize )    // Ŭ¶ó ¿äûÀ¸·Î °Ë»ö°á°ú°¡ ¾ø¾îµµ HEADER¿Í DONEÀ» º¸³»±â À§ÇØ ÁÖ¼®Ã³¸®
//     {
//         SendErrorMessage(T_FC_MARKET_SEARCH_REQUEST, ERR_DB_NO_SUCH_DATA, 101);
//         return RES_BREAK;
//     }

    ///////////////////////////////////////////////
    // °Ë»ö°á°ú °¡°Ý º°·ç Á¤·Ä
    sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_PRICE_UP());
    m_nLatelyMarketListSortingType = MARKET_SORT_PRICE_UP;

    ///////////////////////////////////////////////
    // °Ë»ö°á°ú º¸³»±â
    SendAddMessageType(T_FC_MARKET_SEARCH_HEADER);
    itr = m_CopyMarketListPtr.begin();
    for ( int i = 0 ; i < MARKET_VIEW_LIST_COUNT ; i++, itr++ )
    {
        if ( itr == m_CopyMarketListPtr.end() )    // Ç׸ñÀÌ 8°Ô ¹Ì¸¸À϶§ ÇØ´ç
        {
            break;
        }
        INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_SEARCH_OK, T_FC_MARKET_SEARCH_OK, pSendOKMsg, pSendOKBuf);
        MARKET_INFO tmMarket(*itr);
        memcpy(&pSendOKMsg->MarketInfo, &tmMarket, sizeof(pSendOKMsg->MarketInfo));
        SendAddData(pSendOKBuf, MSG_SIZE(MSG_FC_MARKET_SEARCH_OK));
    }
    INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_SEARCH_DONE, T_FC_MARKET_SEARCH_DONE, pSendDoneMsg, pSendDoneBuf);
    pSendDoneMsg->ItemCount = nCopyMarketListSize;
    pSendDoneMsg->MaxPage = (nCopyMarketListSize / MARKET_VIEW_LIST_COUNT) + (0 == (nCopyMarketListSize % MARKET_VIEW_LIST_COUNT) ? 0 : 1);
    pSendDoneMsg->CurrentPage = 1;
    SendAddData(pSendDoneBuf, MSG_SIZE(MSG_FC_MARKET_SEARCH_DONE));
        return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_MARKET_PAGING_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_PAGING_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_MARKET_PAGING_REQUEST,
        MSG_FC_MARKET_PAGING_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_PAGING_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( 0 == pRMsg->MarketUID )    // 0°ªÀÌ¸é ¼ø¼ö ÆäÀÌÁö º¯°æ ¿äû. ¹Ý´ë·Î 0 °ªÀÌ ¾Æ´Ï¸é ±¸¸Å¿Ï·á ÈÄ ÆäÀÌÁö °»½Å ¿äûÀ̹ǷΠÅÒüũ¸¦ ÇÏÁö ¾Ê´Â´Ù.
    {
        if ( (MARKET_PACKET_RECV_TICK_BUY_PAGE/2) > GetTickCount() - m_nLatelyMarketPacketRecvTick_BuyPage )
        {
            SendErrorMessage(T_FC_MARKET_PAGING_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
            return RES_BREAK;
        }
    }
    m_nLatelyMarketPacketRecvTick_BuyPage = GetTickCount();
    
    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_PAGING_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_PAGING_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // Á¦¿Ü½Ãų Ç׸ñÀÌ ÀÖ´ÂÁö È®ÀÎ
    if ( 0 != pRMsg->MarketUID )
    {
        MARKET_ITR delitr = m_CopyMarketListPtr.begin();
        for( ; delitr != m_CopyMarketListPtr.end() ; delitr++ )
        {
            if ( pRMsg->MarketUID == (*delitr)->MarketUID )
            {
                m_CopyMarketListPtr.erase(delitr);
                break;
            }
        }
    }
    
    ///////////////////////////////////////////////
    // Ä«ÇÇÇÑ ¸®½ºÆ® È®ÀÎ
    int nCopyMarketListSize = m_CopyMarketListPtr.size();
    if ( 0 >= nCopyMarketListSize )
    {
        SendAddMessageType(T_FC_MARKET_PAGING_HEADER);
        INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_PAGING_DONE, T_FC_MARKET_PAGING_DONE, pSendDoneMsg, pSendDoneBuf);
        SendAddData(pSendDoneBuf, MSG_SIZE(MSG_FC_MARKET_PAGING_DONE));
        return RES_RETURN_TRUE;
    }

    ///////////////////////////////////////////////
    // ÆäÀÌÁö¿¡ ÀÖ´Â ¸¶Áö¸· ¾ÆÀÌÅÛÀ» ±¸¸ÅÇßÀ»°æ¿ì »ç¶óÁö´Â ÆäÀÌÁö¿¡ ´ëÇÑ ¿¹¿Üó¸® Ãß°¡
    int nMaxPage = (nCopyMarketListSize / MARKET_VIEW_LIST_COUNT) + (0 == (nCopyMarketListSize % MARKET_VIEW_LIST_COUNT) ? 0 : 1);
    if ( nMaxPage < pRMsg->SelectPage )
    {
        pRMsg->SelectPage--;
    }
    if ( 0 >= pRMsg->SelectPage )
    {
        SendAddMessageType(T_FC_MARKET_PAGING_HEADER);
        INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_PAGING_DONE, T_FC_MARKET_PAGING_DONE, pSendDoneMsg, pSendDoneBuf);
        SendAddData(pSendDoneBuf, MSG_SIZE(MSG_FC_MARKET_PAGING_DONE));
        return RES_RETURN_TRUE;
    }

    ///////////////////////////////////////////////
    // ¿Ã¹Ù¸¥ ÆäÀÌÁö ¹øÈ£ÀÎÁö È®ÀÎ
    if ( FALSE == IS_IN_RANGE(1, pRMsg->SelectPage, nMaxPage) ) 
    {
        SendErrorMessage(T_FC_MARKET_PAGING_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ÆÐÀÌ¡ °Ë»ö °á°ú º¸³»±â
    int nIndex = 0;
    nIndex = MARKET_VIEW_LIST_COUNT*(pRMsg->SelectPage-1);
    SendAddMessageType(T_FC_MARKET_PAGING_HEADER);
    for ( int i = 0 ; i < MARKET_VIEW_LIST_COUNT ; i++ )
    {
        if ( nIndex+i >= nCopyMarketListSize )    // ¸¶Áö¸· ÆÐÀÌÁö À϶§¸¸ ÇØ´ç
        {
            break;
        }
        INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_PAGING_OK, T_FC_MARKET_PAGING_OK, pSendOKMsg, pSendOKBuf);
        MARKET_INFO tmMarket(*m_CopyMarketListPtr[nIndex+i]);
        memcpy(&pSendOKMsg->MarketInfo, &tmMarket, sizeof(pSendOKMsg->MarketInfo));
        SendAddData(pSendOKBuf, MSG_SIZE(MSG_FC_MARKET_PAGING_OK));
    }
    INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_PAGING_DONE, T_FC_MARKET_PAGING_DONE, pSendDoneMsg, pSendDoneBuf);
    pSendDoneMsg->ItemCount = nCopyMarketListSize;
    pSendDoneMsg->MaxPage = nMaxPage;
    pSendDoneMsg->CurrentPage = pRMsg->SelectPage;
    SendAddData(pSendDoneBuf, MSG_SIZE(MSG_FC_MARKET_PAGING_DONE));
    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_MARKET_SORT_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_MARKET_SORT_REQUEST,
        MSG_FC_MARKET_SORT_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( MARKET_PACKET_RECV_TICK_BUY_PAGE > GetTickCount() - m_nLatelyMarketPacketRecvTick_BuyPage )
    {
        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_BuyPage = GetTickCount();
    
    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // Ä«ÇÇÇÑ ¸®½ºÆ® È®ÀÎ
    int nCopyMarketListSize = m_CopyMarketListPtr.size();
    if ( 0 >= nCopyMarketListSize )
    {
        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_DB_NO_SUCH_DATA, 101);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // Áߺ¹ Á¤·Ä ¿äû¿©ºÎ È®ÀÎ
    if ( pRMsg->SortingType == m_nLatelyMarketListSortingType )
    {
        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, 100);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // Á¤·Ä
    switch (pRMsg->SortingType)
    {
    case MARKET_SORT_PRICE_UP:        sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_PRICE_UP());        break;
    case MARKET_SORT_PRICE_DOWN:    sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_PRICE_DOWN());    break;
    case MARKET_SORT_LEVEL_UP:        sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_LEVEL_UP());        break;
    case MARKET_SORT_LEVEL_DOWN:    sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_LEVEL_DOWN());    break;
    case MARKET_SORT_ENCHANT_UP:    sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_ENCHANT_UP());    break;
    case MARKET_SORT_ENCHANT_DOWN:    sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_ENCHANT_DOWN());    break;
    case MARKET_SORT_NAME_UP:        sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_NAME_UP());        break;
    case MARKET_SORT_NAME_DOWN:        sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_NAME_DOWN());        break;
    case MARKET_SORT_TIME_UP:        sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_TIME_UP());        break;
    case MARKET_SORT_TIME_DOWN:        sort(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_SORT_TIME_DOWN());        break;
    default:                        SendErrorMessage(T_FC_MARKET_SORT_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, 101);    return RES_BREAK;
    }
    m_nLatelyMarketListSortingType = pRMsg->SortingType;
    
    ///////////////////////////////////////////////
    // Á¤·Ä°á°ú º¸³»±â
    SendAddMessageType(T_FC_MARKET_SORT_HEADER);
    MARKET_ITR itr = m_CopyMarketListPtr.begin();
    for ( int i = 0 ; i < MARKET_VIEW_LIST_COUNT ; i++, itr++ )
    {
        if ( itr == m_CopyMarketListPtr.end() )    // Ç׸ñÀÌ 8°Ô ¹Ì¸¸À϶§ ÇØ´ç
        {
            break;
        }
        INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_SORT_OK, T_FC_MARKET_SORT_OK, pSendOKMsg, pSendOKBuf);
        MARKET_INFO tmMarket(*itr);
        memcpy(&pSendOKMsg->MarketInfo, &tmMarket, sizeof(pSendOKMsg->MarketInfo));
        SendAddData(pSendOKBuf, MSG_SIZE(MSG_FC_MARKET_SORT_OK));
    }
    INIT_MSG_WITH_BUFFER(MSG_FC_MARKET_SORT_DONE, T_FC_MARKET_SORT_DONE, pSendDoneMsg, pSendDoneBuf);
    pSendDoneMsg->ItemCount = nCopyMarketListSize;
    pSendDoneMsg->MaxPage = (nCopyMarketListSize / MARKET_VIEW_LIST_COUNT) + (0 == (nCopyMarketListSize % MARKET_VIEW_LIST_COUNT) ? 0 : 1);
    pSendDoneMsg->CurrentPage = 1;
    SendAddData(pSendDoneBuf, MSG_SIZE(MSG_FC_MARKET_SORT_DONE));
    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_MARKET_BUY_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP,101);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_MARKET_BUY_REQUEST,
        MSG_FC_MARKET_BUY_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND,102);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( MARKET_PACKET_RECV_TICK_BUY_PAGE > GetTickCount() - m_nLatelyMarketPacketRecvTick_BuyPage )
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_INTERVAL_SYSTEM_SECOND,103);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_BuyPage = GetTickCount();

#ifdef SC_MARKET_NOT_USE_NORMAL_INFL            // 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )
    if ( INFLUENCE_TYPE_NORMAL == IS_NORMAL_INFLUENCE_TYPE(m_character.InfluenceType) )            // ÀϹݼ¼·Â ÀÌ¿ëºÒ°¡ 
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_REQ_CHOOSE_INFLUENCE_TYPE,104);
        return RES_BREAK;
    }
#endif        // End. 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )

    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // Ä«ÇÇÇÑ ¸®½ºÆ®¿¡ ÀÖ´ÂÁö È®ÀÎ
    MARKET_ITR itr = find_if(m_CopyMarketListPtr.begin(), m_CopyMarketListPtr.end(), MARKET_LIST_MarketUID_Find_Object(pRMsg->MarketUID));
    if(itr >= m_CopyMarketListPtr.end())
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP_ITEM, 105);
        return RES_BREAK;
    }

#ifdef SC_MARKET_NOT_USE_NORMAL_INFL        // 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )
    // µ¿Àϼ¼·Â°£ °Å·¡ÀÎÁö È®ÀÎ  
    if( (*itr)->MarketItemInfl != m_character.InfluenceType )  
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_REQ_INFLUENCE_NOT_MATCHED,106);
        return RES_BREAK;
    }
#endif    // End. 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )

    ///////////////////////////////////////////////
    // ±¸¸Å°¡ °¡´ÉÇÑ »óÅÂÀÎÁö È®ÀÎ
    ATUM_DATE_TIME tmCurrentTime(TRUE);
    if ( MARKET_STATE_SELL != (*itr)->MarketState || MARKET_SELLING_MINUTES < tmCurrentTime.GetTimeDiffTimeInMinutes((*itr)->RegistTime) )
    {
        SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP_ITEM, 107);
        return RES_BREAK;
    }

    if ( MARKET_MONEY_TYPE_SPI == (*itr)->MoneyType )
    {
        ITEM_GENERAL *pItemSPI = m_ItemManager.GetFirstItemGeneralByItemNum(MONEY_ITEM_NUMBER, ITEM_IN_CHARACTER);
        if ( NULL == pItemSPI )
        {    // SPI ¾ÆÀÌÅÛÀÌ ¾øÀ» °æ¿ì Ãß°¡
            m_ItemManager.InsertItemBaseByItemNum(MONEY_ITEM_NUMBER, 0, IUT_GENERAL);
            SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_NO_SUCH_ITEM_INFO, MONEY_ITEM_NUMBER);
            return RES_BREAK;
        }

        ///////////////////////////////////////////////
        // º¸À¯ SPI·Î ±¸¸Å ±Ý¾× ºñ±³
        if ( pItemSPI->CurrentCount < (*itr)->Price )
        {
            SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_NOT_ENOUGH_MONEY, pItemSPI->CurrentCount, (*itr)->Price, "SPI");
            return RES_BREAK;
        }
    }
    else if ( MARKET_MONEY_TYPE_WP == (*itr)->MoneyType )
    {
        ///////////////////////////////////////////////
        // º¸À¯ WP·Î ±¸¸Å ±Ý¾× ºñ±³
        if ( m_character.WarPoint < (*itr)->Price )
        {
            SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_NOT_ENOUGH_MONEY, m_character.WarPoint, (*itr)->Price, "WP");
            return RES_BREAK;
        }
    }

    ///////////////////////////////////////////////
    // Ä«¿îÅÍºí ¾ÆÀÌÅÛÀÏ °æ¿ì ÃÖ´ë º¸À¯°¡´É ¼ö üũ
    BOOL bIsCountableAndHaveItem = FALSE;
    ITEM_GENERAL *pItemG = m_ItemManager.GetFirstItemGeneralByItemNum((*itr)->ItemNum, ITEM_IN_CHARACTER);
    if ( NULL != pItemG )
    {
        //if ( IS_GENERAL_ITEM(pItemG->Kind) )
        if ( IS_COUNTABLE_ITEM(pItemG->Kind) )            
        {
            bIsCountableAndHaveItem = TRUE;
            if ( MAX_ITEM_COUNTS < pItemG->CurrentCount + (*itr)->ItemCount )
            {
                SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_MAX_ITEM_COUNTS_OVER);
                return RES_BREAK;
            }
        }
    }
    else
    {
        ///////////////////////////////////////////////
        // Àκ¥Å丮 °ø°£È®ÀÎ
        if (m_ItemManager.GetInventoryItemCounts() >= m_ItemManager.GetMaxInventoryCount())
        {
            SendErrorMessage(T_FC_MARKET_BUY_REQUEST, ERR_PROTOCOL_INVENTORY_FULL_ITEM, 0, m_ItemManager.GetMaxInventoryCount());
            return RES_BREAK;
        }
    }

    MARKET_INFO *pQParam = new MARKET_INFO((*itr));
    ms_pFieldIOCP->m_pAtumDBManager->MakeAndEnqueueQuery(QT_Market_Buying, this, m_character.AccountUniqueNumber, pQParam, NULL, (INT64)bIsCountableAndHaveItem);
    
    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_MARKET_SELL_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_MARKET_SELL_REQUEST,
        MSG_FC_MARKET_SELL_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( MARKET_PACKET_RECV_TICK_SELL_PAGE > GetTickCount() - m_nLatelyMarketPacketRecvTick_SellPage )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_SellPage = GetTickCount();

    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }

#ifdef SC_MARKET_NOT_USE_NORMAL_INFL            // 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )
    if ( INFLUENCE_TYPE_NORMAL == IS_NORMAL_INFLUENCE_TYPE(m_character.InfluenceType) )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_REQ_CHOOSE_INFLUENCE_TYPE);
        return RES_BREAK;
    }
#endif        // End. 2014-06-17 by bckim, ¼¼·Â ºÒ±ÕÇü ( °Å·¡¼Ò µ¿Àϼ¼·Â°£¿¡¸¸ °Å·¡°¡ ÀÌ·ç¾îÁö°Ô ¼öÁ¤ )

    ///////////////////////////////////////////////
    // µî·Ï °¡´É °¹¼ö¸¦ ÃÊ°úÇÏ´ÂÁö È®ÀÎ
    if ( TRUE == m_ItemManager.IsExistPremiumCard() )
    {
        if ( (MARKET_SELL_ITEM_COUNT*2) <= m_nMarketRegistrationCount )        // ¸É¹ö½± À¯Àú´Â 2¹è 20°³
        {
            SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_OVER_COUNT, m_nMarketRegistrationCount, 1);
            return RES_BREAK;
        }
    }
    else
    {
        if ( MARKET_SELL_ITEM_COUNT <= m_nMarketRegistrationCount )            // ÀÏ¹Ý À¯Àú´Â 10°³
        {
            SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_OVER_COUNT, m_nMarketRegistrationCount, 0);
            return RES_BREAK;
        }
    }

    ///////////////////////////////////////////////
    // ÆǸŠÇÏ·Á´Â ¾ÆÀÌÅÛÀ» º¸À¯ÁßÀÎÁö È®ÀÎ
    ITEM_GENERAL *pItemG = m_ItemManager.GetItemGeneralByUID(pRMsg->ItemUID, ITEM_IN_CHARACTER);
    if ( NULL == pItemG )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_NO_SUCH_ITEM, pRMsg->ItemUID);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // °Å·¡°¡ °¡´ÉÇÑ ¾ÆÀÌÅÛÀÎÁö üũ
    // 2013-12-03 by bckim, Àӽà ÁÖ¼® 
    /*
    if ( COMPARE_BIT_FLAG(pItemG->ItemInfo->ItemAttribute, ITEM_ATTR_NO_TRANSFER|ITEM_ATTR_KILL_MARK_ITEM|ITEM_ATTR_ACCOUNT_POSSESSION) 
        || POS_INVALID_POSITION >= pItemG->ItemWindowIndex )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_ITEM_CANNOT_TRANSFER, pItemG->ItemNum, pItemG->ItemWindowIndex);
        return RES_BREAK;
    }
    */
    // End. 2013-12-03 by bckim, Àӽà ÁÖ¼® 
    
    ///////////////////////////////////////////////
    // ÀÌ¹Ì »ç¿ëÇÑ ¾ÆÀÌÅÛÀÎÁö üũ
    if ( ITEMKIND_ACCESSORY_TIMELIMIT == pItemG->Kind && pItemG->UsingTimeStamp != ITEM_NOT_USING )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_ALREADY_USE_ITEM);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ÀåÂøÁßÀÎ ¾ÆÀÌÅÛÀÎÁö È®ÀÎ
    if ( WEAR_ATTACHED == pItemG->Wear )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_ATTACHED_ITEM, 101);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ÆǸŠÇÏ·Á´Â È­Æó ŸÀÔÀÌ ¿Ã¹Ù¸¥Áö È®ÀÎ
    if ( MARKET_MONEY_TYPE_SPI != pRMsg->MoneyType && MARKET_MONEY_TYPE_WP != pRMsg->MoneyType )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, pRMsg->MoneyType, 0, "MoneyType");
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ÆÇ¸Å±Ý¾× È®ÀÎ
    if ( FALSE == IS_IN_RANGE(1, pRMsg->Price, MAX_ITEM_COUNTS) )
    {
        SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, pRMsg->Price, 0, "Price");
        return RES_BREAK;
    }

    BOOL bIsCountableItem = FALSE;
    if ( TRUE == IS_COUNTABLE_ITEM(pItemG->Kind))
    {
        bIsCountableItem = TRUE;
        ///////////////////////////////////////////////
        // Ä«¿îÅÍºí ¾ÆÀÌÅÛÀÏ °æ¿ì ÆǸżö·® È®ÀÎ
        if ( FALSE == IS_IN_RANGE(1, pRMsg->Count, pItemG->CurrentCount) )
        {
            SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, pRMsg->Count, pItemG->CurrentCount, "CountableCount");
            return RES_BREAK;
        }
    }
//     else
//     {
//         ///////////////////////////////////////////////
//         // Ä«¿îÅÍºí ¾ÆÀÌÅÛÀÌ ¾Æ´Ò °æ¿ì ÆǸżö·® È®ÀÎ
//         if ( 1 != pRMsg->Count )
//         {
//             SendErrorMessage(T_FC_MARKET_SELL_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, pRMsg->Count, pItemG->CurrentCount, "Count");
//             return RES_BREAK;
//         }
//     }

    ///////////////////////////////////////////////
    // µî·Ï °¡´É °¹¼ö Áõ°¡
    m_nMarketRegistrationCount++;

    MSG_FC_MARKET_SELL_REQUEST *pQParam = new MSG_FC_MARKET_SELL_REQUEST;
    MEMSET_ZERO(pQParam, sizeof(MSG_FC_MARKET_SELL_REQUEST));
    memcpy(pQParam, pRMsg, sizeof(MSG_FC_MARKET_SELL_REQUEST));
    ms_pFieldIOCP->m_pAtumDBManager->MakeAndEnqueueQuery(QT_Market_ItemRegistration, this, m_character.AccountUniqueNumber, pQParam, NULL, (INT64)GetMarketItemKindByOriginItemKind(*pItemG->ItemInfo), (INT64)bIsCountableItem);
    
    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_MARKET_GET_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_MARKET_GET_REQUEST,
        MSG_FC_MARKET_GET_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( MARKET_PACKET_RECV_TICK_GET_REQUEST > GetTickCount() - m_nLatelyMarketPacketRecvTick_GetRequeste )
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_GetRequeste = GetTickCount();

    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ¿øº» ¸®½ºÆ®¸¦ ÅëÇØ ÆǸÅÇöȲ¿¡ ÀÖ´Â Ç׸ñÀÎÁö È®ÀÎ
    MARKET_INFO *pMyKarKetItem = ms_pFieldIOCP->m_pMarketDataManager->GetpMarketInfo(pRMsg->MarketUID);
    if ( NULL == pMyKarKetItem )
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_NO_SUCH_ITEM);
        return RES_BREAK;
    }
    if ( m_character.CharacterUniqueNumber != pMyKarKetItem->CharacterUID )    // ³» ¼ÒÀ¯°¡ ¸Â´ÂÁö È®ÀÎ
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, 100);
        return RES_BREAK;
    }
    if ( MARKET_STATE_DELETE == pMyKarKetItem->MarketState )    // ȸ¼ö °¡´ÉÇÑ »óÅÂÀÎÁö È®ÀÎ
    {
        SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, 101);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // µ·À» ȸ¼öÇÒ¶§ ÃÖ´ëÄ¡ È®ÀÎ
    if ( MARKET_STATE_SELL_DONE == pMyKarKetItem->MarketState )
    {
        if ( MARKET_MONEY_TYPE_SPI == pMyKarKetItem->MoneyType )
        {
            ITEM_GENERAL *pItemSPI = m_ItemManager.GetFirstItemGeneralByItemNum(MONEY_ITEM_NUMBER, ITEM_IN_CHARACTER);
            if ( NULL != pItemSPI )
            {    // 2014-07-24 by bckim, °Å·¡¼Ò ±Ý¾×ȸ¼ö µ¿±âÈ­ ¹®Á¦ º¸¿Ï
                //if ( MAX_ITEM_COUNTS < (pItemSPI->CurrentCount+pMyKarKetItem->Price-GetMarketSellChargeSPI(pMyKarKetItem->Price)) )
                if ( MAX_ITEM_COUNTS < (INT64)(pItemSPI->CurrentCount)+(INT64)(pMyKarKetItem->Price)-(INT64)(GetMarketSellChargeSPI(pMyKarKetItem->Price)) )
                {
                    // 2014-07-24 by bckim, °Å·¡¼Ò ±Ý¾×ȸ¼ö µ¿±âÈ­ ¹®Á¦ º¸¿Ï
                    //SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_MAX_ITEM_COUNTS_OVER, pItemSPI->CurrentCount, pMyKarKetItem->Price, "SPI");
                    SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_NOTIFY_MAX_ITEM_COUNTS_OVER, pItemSPI->CurrentCount, pMyKarKetItem->Price, "SPI");
                    return RES_BREAK;
                }
            }
        }
        else if ( MARKET_MONEY_TYPE_WP == pMyKarKetItem->MoneyType )
        {    // 2014-07-24 by bckim, °Å·¡¼Ò ±Ý¾×ȸ¼ö µ¿±âÈ­ ¹®Á¦ º¸¿Ï
            //if ( MAX_ITEM_COUNTS < (m_character.WarPoint+pMyKarKetItem->Price-GetMarketSellChargeWP(pMyKarKetItem->Price)) )
            if ( MAX_ITEM_COUNTS < (INT64)(m_character.WarPoint)+(INT64)(pMyKarKetItem->Price)-(INT64)(GetMarketSellChargeWP(pMyKarKetItem->Price)) )
            {
                // 2014-07-24 by bckim, °Å·¡¼Ò ±Ý¾×ȸ¼ö µ¿±âÈ­ ¹®Á¦ º¸¿Ï
                //SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_MAX_ITEM_COUNTS_OVER, m_character.WarPoint, pMyKarKetItem->Price, "WP");
                SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_NOTIFY_MAX_ITEM_COUNTS_OVER, m_character.WarPoint, pMyKarKetItem->Price, "WP");
                return RES_BREAK;
            }
        }
    }

    ///////////////////////////////////////////////
    // Ä«¿îÅÍºí ¾ÆÀÌÅÛÀÏ °æ¿ì ÃÖ´ë º¸À¯°¡´É ¼ö üũ
    BOOL bIsCountableAndHaveItem = FALSE;
    ITEM_GENERAL *pItemG = m_ItemManager.GetFirstItemGeneralByItemNum(pMyKarKetItem->ItemNum, ITEM_IN_CHARACTER);
    if ( NULL != pItemG )
    {
        if ( IS_COUNTABLE_ITEM(pItemG->Kind) )        // 2014-05-09 by bckim, °Å·¡¼Ò ¾ÆÀÌÅÛ º¹»ç¹ö±× ¼öÁ¤  
        {
            bIsCountableAndHaveItem = TRUE;
            if ( MAX_ITEM_COUNTS < pItemG->CurrentCount + pMyKarKetItem->ItemCount )
            {
                SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_MAX_ITEM_COUNTS_OVER);
                return RES_BREAK;
            }
        }
    }
    else
    {
        ///////////////////////////////////////////////
        // Àκ¥Å丮 °ø°£È®ÀÎ
        if ( MARKET_STATE_SELL_DONE != pMyKarKetItem->MarketState )            // ÆÇ¸ÅµÈ ¹°Ç°ÀÇ ±Ý¾×ȸ¼öÀÏ‹š´Â Àκ¥Å丮 üũ ¾ÈÇÔ. 
        {
        if (m_ItemManager.GetInventoryItemCounts() >= m_ItemManager.GetMaxInventoryCount())
        {
            SendErrorMessage(T_FC_MARKET_GET_REQUEST, ERR_PROTOCOL_INVENTORY_FULL_ITEM, 0, m_ItemManager.GetMaxInventoryCount());
            return RES_BREAK;
        }
        }
        
    }
    
    ///////////////////////////////////////////////
    // µî·Ï °¡´É °¹¼ö °¨¼Ò
    m_nMarketRegistrationCount = max(0, m_nMarketRegistrationCount-1);

    MSG_FC_MARKET_GET_REQUEST *pQParam = new MSG_FC_MARKET_GET_REQUEST;
    MEMSET_ZERO(pQParam, sizeof(MSG_FC_MARKET_GET_REQUEST));
    memcpy(pQParam, pRMsg, sizeof(MSG_FC_MARKET_GET_REQUEST));
    ms_pFieldIOCP->m_pAtumDBManager->MakeAndEnqueueQuery(QT_Market_GetTradeItem, this, m_character.AccountUniqueNumber, pQParam, NULL, (INT64)bIsCountableAndHaveItem);

    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_MARKET_MY_LIST_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pMarketDataManager )
    {
        SendErrorMessage(T_FC_MARKET_MY_LIST_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_MARKET_MY_LIST_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // °Å·¡¼Ò °ü·Ã 2ÃÊ ÅÒ
    if ( MARKET_PACKET_RECV_TICK_MY_LIST_PAGE > GetTickCount() - m_nLatelyMarketPacketRecvTick_MyListPage )
    {
        SendErrorMessage(T_FC_MARKET_MY_LIST_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_MyListPage = GetTickCount();

    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_MARKET_MY_LIST_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_MARKET_MY_LIST_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }
    
    ms_pFieldIOCP->m_pAtumDBManager->MakeAndEnqueueQuery(QT_Market_GetSaleList, this, m_character.AccountUniqueNumber, NULL);
    
    return RES_RETURN_TRUE;
}
// end 2013-11-25 by jhseol&bckim, °Å·¡¼Ò - ÆÐŶ ¸®½Ãºê ÇÔ¼ö ±¸Çö

// 2014-01-03 by jhseol&bckim, Æı«°æ¸ÅÀå - ÆÐŶ ¸®½Ãºê ÇÔ¼ö¼±¾ð
ProcessResult CFieldIOCPSocket::Process_FC_DESTROY_AUCTION_BASE_INFO_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pDestroyAuctionManager)
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_DESTROY_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // Æı«°æ¸Å°¡ ÁøÇàÁßÀÎÁö üũ
    if ( FALSE == ms_pFieldIOCP->m_bDestroyAuctionInProgress || TRUE == ms_pFieldIOCP->m_pDestroyAuctionManager->GetDestroyAuctionListPtr()->empty() )    
    {    // 2014-07-07 by bckim, Æı«°æ¸Å°¡ ½ÃÀ۵Ǿ µî·ÏµÈ ¹°Ç°ÀÌ ¾øÀ¸¸é ½ÃÀÛ ¸Þ¼¼Áö¸¦ º¸³»Áö ¾ÊÀ½.         
        // ÇöÀç °æ¸ÅÁøÇàÁßÀÌ ¾Æ´Ï°Å³ª µî·ÏµÈ ¹°Ç°ÀÌ ¾øÀ»¶§,
        SendErrorMessage(T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST, ERR_COUNTDOWN_NOT_ENOUGH_TIME);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå °ü·Ã 0.2ÃÊ ÅÒ
    if ( DESTROY_AUCTION_PACKET_RECV_TICK > GetTickCount() - m_nLatelyMarketPacketRecvTick_GetRequeste )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_GetRequeste = GetTickCount();

    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // °æ¸Å¹°Ç° º¸³»±â
//    SendAddMessageType(T_FC_DESTROY_AUCTION_BASE_INFO_HEADER);
    INIT_MSG_WITH_BUFFER(MSG_FC_DESTROY_AUCTION_BASE_INFO_HEADER, T_FC_DESTROY_AUCTION_BASE_INFO_HEADER, pSendHeaderMsg, pSendHeaderBuf);
    pSendHeaderMsg->DAuctionEndTime = ms_pFieldIOCP->m_pDestroyAuctionManager->GetDestroyAuctionEndTime();
    SendAddData(pSendHeaderBuf, MSG_SIZE(MSG_FC_DESTROY_AUCTION_BASE_INFO_HEADER));

    DESTROY_AUCTION_ITR itr = ms_pFieldIOCP->m_pDestroyAuctionManager->GetDestroyAuctionListPtr()->begin();
    while( itr != ms_pFieldIOCP->m_pDestroyAuctionManager->GetDestroyAuctionListPtr()->end() )
    {
        INIT_MSG_WITH_BUFFER(MSG_FC_DESTROY_AUCTION_BASE_INFO_OK, T_FC_DESTROY_AUCTION_BASE_INFO_OK, pSendOKMsg, pSendOKBuf);
        DESTROY_AUCTION_INFO tmDAuctionInfo(*itr);
        memcpy(&pSendOKMsg->DAuctionInfo, &tmDAuctionInfo, sizeof(pSendOKMsg->DAuctionInfo));
        SendAddData(pSendOKBuf, MSG_SIZE(MSG_FC_DESTROY_AUCTION_BASE_INFO_OK));
        itr++;
    }

    SendAddMessageType(T_FC_DESTROY_AUCTION_BASE_INFO_DONE);
    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_DESTROY_AUCTION_TENDER_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pDestroyAuctionManager)
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_DESTROY_AUCTION_TENDER_REQUEST,
        MSG_FC_DESTROY_AUCTION_TENDER_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_DESTROY_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // Æı«°æ¸Å°¡ ÁøÇàÁßÀÎÁö üũ
    if ( FALSE == ms_pFieldIOCP->m_bDestroyAuctionInProgress || TRUE == ms_pFieldIOCP->m_pDestroyAuctionManager->GetDestroyAuctionListPtr()->empty() )    
    {    // 2014-07-07 by bckim, Æı«°æ¸Å°¡ ½ÃÀ۵Ǿ µî·ÏµÈ ¹°Ç°ÀÌ ¾øÀ¸¸é ½ÃÀÛ ¸Þ¼¼Áö¸¦ º¸³»Áö ¾ÊÀ½.         
        // ÇöÀç °æ¸ÅÁøÇàÁßÀÌ ¾Æ´Ï°Å³ª µî·ÏµÈ ¹°Ç°ÀÌ ¾øÀ»¶§,
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_COUNTDOWN_NOT_ENOUGH_TIME);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå °ü·Ã 0.2ÃÊ ÅÒ
    if ( DESTROY_AUCTION_PACKET_RECV_TICK > GetTickCount() - m_nLatelyMarketPacketRecvTick_GetRequeste )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_GetRequeste = GetTickCount();
    
    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ÀÔÂû°¡´ÉÇÑ ±Ý¾×À» ¼ÒÀ¯ÁßÀÎÁö È®ÀÎ
    ITEM_GENERAL *pItemSPI = m_ItemManager.GetFirstItemGeneralByItemNum(MONEY_ITEM_NUMBER, ITEM_IN_CHARACTER);
    if ( NULL == pItemSPI )
    {    // SPI ¾ÆÀÌÅÛÀÌ ¾øÀ» °æ¿ì Ãß°¡
        m_ItemManager.InsertItemBaseByItemNum(MONEY_ITEM_NUMBER, 0, IUT_GENERAL);
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_PROTOCOL_NO_SUCH_ITEM_INFO, MONEY_ITEM_NUMBER);
        return RES_BREAK;
    }
    if ( pItemSPI->CurrentCount < pRMsg->TenderPrice )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_PROTOCOL_NOT_ENOUGH_MONEY, pItemSPI->CurrentCount, pRMsg->TenderPrice, "SPI");
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ÀÔÂûÁ¶°Ç È®ÀÎ 1. ÀÔÂû±Ç
    // 2014-07-04 by bckim, ¹«·áÁö±Þ ÀÔÂû±Ç ¼Ó¼º º¯°æ 
    //ITEM_GENERAL *pItemTenderItem = m_ItemManager.GetFirstItemGeneralByItemNum(DESTROY_AUCTION_TENDET_ITEM_NUM_LIMITED, ITEM_IN_CHARACTER);
    ITEM_GENERAL *pItemTenderItem = m_ItemManager.GetItemGeneralByItemNumFirstCreateTimeInCharacter(DESTROY_AUCTION_TENDET_ITEM_NUM_LIMITED, ITEM_IN_CHARACTER);
    // End. 2014-07-04 by bckim, ¹«·áÁö±Þ ÀÔÂû±Ç ¼Ó¼º º¯°æ 

    if ( NULL == pItemTenderItem )
    {    // ¿ì¼± ±â°£Á¦ ÀÔÂû±ÇÀÌ ÀÖ´ÂÁö È®ÀÎ ¾øÀ¸¸é ¹«Á¦ÇÑ ÀÔÂû±Ç È®ÀÎ
        pItemTenderItem = m_ItemManager.GetFirstItemGeneralByItemNum(DESTROY_AUCTION_TENDET_ITEM_NUM_UNLIMITED, ITEM_IN_CHARACTER);
        if ( NULL == pItemTenderItem )
        {
            //SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_PROTOCOL_NO_SUCH_ITEM, DESTROY_AUCTION_TENDET_ITEM_NUM_LIMITED, DESTROY_AUCTION_TENDET_ITEM_NUM_UNLIMITED, "BiddingRights");
            SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_CANNOT_BUY_ITEM,DESTROY_AUCTION_TENDET_ITEM_NUM_LIMITED, DESTROY_AUCTION_TENDET_ITEM_NUM_UNLIMITED, "BiddingRights");
// #if defined(TEST140)
//             SendString128(STRING_128_USER_POPUP, "Àӽà °æ¸ÅÀÔÂû±Ç [%d]¶Ç´Â [%d]ÀÌ ÇÊ¿äÇÕ´Ï´Ù.", DESTROY_AUCTION_TENDET_ITEM_NUM_LIMITED, DESTROY_AUCTION_TENDET_ITEM_NUM_UNLIMITED);
// #endif
            return RES_BREAK;
        }
    }

    ///////////////////////////////////////////////
    // ÀÔÂûÁ¶°Ç È®ÀÎ 2. °æ¸Å¹°Ç° »óÅÂ
    mt_auto_lock mtA(ms_pFieldIOCP->m_pDestroyAuctionManager->GetDestroyAuctionListPtr());
    DESTROY_AUCTION_INFO *pDAuctionInfo = ms_pFieldIOCP->m_pDestroyAuctionManager->GetpDestroyAuctionInfo(pRMsg->DAuctionUID);
    if ( NULL == pDAuctionInfo )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_DB_NO_SUCH_DATA, pRMsg->DAuctionUID);
        return RES_BREAK;
    }
    if ( pDAuctionInfo->CharacterUID == m_character.CharacterUniqueNumber )    // ÇöÀç ÀÚ½ÅÀÌ ÃÖ°í ÀÔÂûÀÚ ÀÌ´Ù. ÃÊ°úÀÔÂû ±ÝÁö
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_PROTOCOL_NO_SUCH_REQUEST_TYPE, pDAuctionInfo->CharacterUID, m_character.CharacterUniqueNumber, "CUID");
        return RES_BREAK;
    }
    if ( pDAuctionInfo->Price >= pRMsg->TenderPrice )                        // »óȸ ÀÔÂûÀÚ°¡ ÀÖ´Ù.
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_TENDER_REQUEST, ERR_PROTOCOL_TRADE_ERROR, pDAuctionInfo->Price, pRMsg->TenderPrice, "Price");
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ÀÔÂû Á¤º¸ º¯°æ
    ms_pFieldIOCP->m_pDestroyAuctionManager->UpdateDestroyAuctionTenderInfo(pRMsg);

    ///////////////////////////////////////////////
    // ÀÔÂû ·Î±× ³²±â±â
    INIT_MSG_WITH_BUFFER(MSG_FL_LOG_DESTROY_AUCTION_TENDER, T_FL_LOG_DESTROY_AUCTION_TENDER, pLogMsg, SendLogBuf);
    memcpy(&pLogMsg->DAuctionInfo, pDAuctionInfo, sizeof(DESTROY_AUCTION_INFO));
    pLogMsg->DAuctionInfo.AccountUID = m_character.AccountUniqueNumber;
    pLogMsg->DAuctionInfo.CharacterUID = m_character.CharacterUniqueNumber;
    pLogMsg->DAuctionInfo.Price = pRMsg->TenderPrice;
    g_pFieldGlobal->SendLogFieldServer2LogServer(SendLogBuf, MSG_SIZE(MSG_FL_LOG_DESTROY_AUCTION_TENDER));
    mtA.auto_unlock_cancel();

    ///////////////////////////////////////////////
    // ÀÔÂû±Ç Â÷°¨
    // 2014-07-04 by bckim, ¹«·áÁö±Þ ÀÔÂû±Ç ¼Ó¼º º¯°æ 
    //m_ItemManager.UpdateItemCountByPointer(pItemTenderItem, -1, IUT_AUCTION);
    if ( DESTROY_AUCTION_TENDET_ITEM_NUM_LIMITED == pItemTenderItem->ItemNum )  // Ä«¿îÅÍºí ¾ÆÀÌÅÛÀÌ ¾Æ´Ô. (ÀÏ¹Ý Æı«¾ÆÀÌÅÛ )
    {
        m_ItemManager.DeleteItemFromCharacterByPointer(pItemTenderItem,IUT_USE_ITEM);
    }
    else // Ä«¿îÅÍºí ¾ÆÀÌÅÛ ( ÇÁ¸®¹Ì¾ö ¾ÆÀÌÅÛ )
    {
    m_ItemManager.UpdateItemCountByPointer(pItemTenderItem, -1, IUT_AUCTION);
    }
    // End. 2014-07-04 by bckim, ¹«·áÁö±Þ ÀÔÂû±Ç ¼Ó¼º º¯°æ     

    ///////////////////////////////////////////////
    // ÀÔÂû Á¤º¸ Æı«°æ¸ÅÀå ÀÌ¿ëÁßÀÎ ¸ðµç À¯Àú¿¡°Ô ½Ç½Ã°£ Àü¼Û
    mt_auto_lock mtB(&ms_pFieldIOCP->m_mapEnterDestroyAuctionBuildingUserSocketList);

    // Àӽà °ª È®ÀÎ 
    int tmsize = ms_pFieldIOCP->m_mapEnterDestroyAuctionBuildingUserSocketList.size();
    g_pFieldGlobal->WriteSystemLogEX(TRUE, "Æı«Á¤º¸ÇöȲ Àü¼Û´ë»ó »çÀÌÁî  (%d)\r\n",tmsize);

    for(mtmapUID2FieldIOCPSocket::iterator itr = ms_pFieldIOCP->m_mapEnterDestroyAuctionBuildingUserSocketList.begin() ; itr != ms_pFieldIOCP->m_mapEnterDestroyAuctionBuildingUserSocketList.end() ;)
    {
        UID32_t temp = itr->first;
        CFieldIOCPSocket *tmp = itr->second;

        if ( NULL != itr->second && TRUE == itr->second->IsValidCharacter(FALSE))
        {
            INIT_MSG_WITH_BUFFER(MSG_FC_DESTROY_AUCTION_TENDER_OK, T_FC_DESTROY_AUCTION_TENDER_OK, pSendOKMsg, pSendOKBuf);
            memcpy(pSendOKMsg, pRMsg, sizeof(MSG_FC_DESTROY_AUCTION_TENDER_OK));
            itr->second->SendAddData(pSendOKBuf, MSG_SIZE(MSG_FC_DESTROY_AUCTION_TENDER_OK));
            // Àӽà °ª È®ÀÎ 
            g_pFieldGlobal->WriteSystemLogEX(TRUE, "Æı«Á¤º¸ÇöȲ ¸®½ºÆ® (%s)\r\n",itr->second->m_character.CharacterName);
            g_pFieldGlobal->WriteSystemLogEX(TRUE, "Æı«Á¤º¸ÇöȲ ¸®½ºÆ® (%d)\r\n",itr->first);
        }

        if(FALSE == itr->second->IsValidCharacter(FALSE))
        {
            // Àӽà °ª È®ÀÎ 
            g_pFieldGlobal->WriteSystemLogEX(TRUE, "Æı«Á¤º¸ÇöȲ IsValidCharacter (%s)\r\n",itr->second->m_character.CharacterName);
            itr = ms_pFieldIOCP->m_mapEnterDestroyAuctionBuildingUserSocketList.erase(itr);
            // Àӽà °ª È®ÀÎ 
            int tmsize2 = ms_pFieldIOCP->m_mapEnterDestroyAuctionBuildingUserSocketList.size();
            g_pFieldGlobal->WriteSystemLogEX(TRUE, "Æı«Á¤º¸ÇöȲ Àü¼Û´ë»ó »çÀÌÁî  (%d)\r\n",tmsize2);
            continue;
        }

        ++itr;
    }

    ///////////////////////////////////////////////
    // º¯°æµÈ ÀÔÂû Á¤º¸ DBÀúÀå
    MSG_FC_DESTROY_AUCTION_TENDER_REQUEST *pQParam = new MSG_FC_DESTROY_AUCTION_TENDER_REQUEST;
    MEMSET_ZERO(pQParam, sizeof(MSG_FC_DESTROY_AUCTION_TENDER_REQUEST));
    memcpy(pQParam, pRMsg, sizeof(MSG_FC_DESTROY_AUCTION_TENDER_REQUEST));
    ms_pFieldIOCP->m_pAtumDBManager->MakeAndEnqueueQuery(QT_DestroyAuction_UpdateBiddingInfo, this, m_character.AccountUniqueNumber, pQParam);

    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_DESTROY_AUCTION_GET_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pDestroyAuctionManager)
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_DESTROY_AUCTION_GET_REQUEST,
        MSG_FC_DESTROY_AUCTION_GET_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_DESTROY_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
//     ///////////////////////////////////////////////
//     // Æı«°æ¸Å°¡ ÁøÇàÁßÀÎÁö üũ
//     if ( FALSE == ms_pFieldIOCP->m_bDestroyAuctionInProgress )
//     {
//         SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_COUNTDOWN_NOT_ENOUGH_TIME);
//         return RES_BREAK;
//     }
    
    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå °ü·Ã 0.2ÃÊ ÅÒ
    if ( DESTROY_AUCTION_PACKET_RECV_TICK > GetTickCount() - m_nLatelyMarketPacketRecvTick_GetRequeste )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_GetRequeste = GetTickCount();
    
    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // ȸ¼ö°¡ °¡´ÉÇÑ »óÅÂÀÎÁö È®ÀÎ
#if defined(TEST140)
#else
    ATUM_DATE_TIME tmCurrentTime(TRUE);
    tmCurrentTime.AddDateTime(0,0,0,-(DESTROY_AUCTION_GET_POSSIBLE_TIME_HOUR),0,0);
    if ( tmCurrentTime > pRMsg->DAuctionGetPossibleTime || AUCTION_ITEM_STATE_END != pRMsg->DAuctionStatus )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_PROTOCOL_TIME_LIMIT_ERROR, pRMsg->DAuctionStatus);
        return RES_BREAK;
    }
#endif

    ///////////////////////////////////////////////
    // ³«Âû±Ý¾× ¼ÒÁö¿©ºÎ È®ÀÎ
    ITEM_GENERAL *pItemSPI = m_ItemManager.GetFirstItemGeneralByItemNum(MONEY_ITEM_NUMBER, ITEM_IN_CHARACTER);
    if ( NULL == pItemSPI )
    {    // SPI ¾ÆÀÌÅÛÀÌ ¾øÀ» °æ¿ì Ãß°¡
        m_ItemManager.InsertItemBaseByItemNum(MONEY_ITEM_NUMBER, 0, IUT_GENERAL);
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_PROTOCOL_NO_SUCH_ITEM_INFO, MONEY_ITEM_NUMBER);
        return RES_BREAK;
    }
    if ( pItemSPI->CurrentCount < pRMsg->Price )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_GET_REQUEST, ERR_PROTOCOL_NOT_ENOUGH_MONEY, pItemSPI->CurrentCount, pRMsg->Price, "SPI");
        return RES_BREAK;
    }

    ///////////////////////////////////////////////
    // DB·Î ¾ÆÅÛ È¸¼ö ¿äûÇϱâ
    MSG_FC_DESTROY_AUCTION_GET_REQUEST *pQParam = new MSG_FC_DESTROY_AUCTION_GET_REQUEST;
    MEMSET_ZERO(pQParam, sizeof(MSG_FC_DESTROY_AUCTION_GET_REQUEST));
    memcpy(pQParam, pRMsg, sizeof(MSG_FC_DESTROY_AUCTION_GET_REQUEST));
    ms_pFieldIOCP->m_pAtumDBManager->MakeAndEnqueueQuery(QT_DestroyAuction_GetAuctionItem, this, m_character.AccountUniqueNumber, pQParam);
    
    return RES_RETURN_TRUE;
}

ProcessResult CFieldIOCPSocket::Process_FC_DESTROY_AUCTION_MY_LIST_REQUEST(const char* pPacket, int nLength, int &nBytesUsed)
{
    ///////////////////////////////////////////////
    // ¸Å´ÏÀú Æ÷ÀÎÅÍ È®ÀÎ
    if ( NULL == ms_pFieldIOCP->m_pDestroyAuctionManager)
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_MY_LIST_REQUEST, ERR_PROTOCOL_NO_SUCH_SHOP);
        return RES_BREAK;
    }
    
    //     DECLARE_MESSAGE_AND_CHECK_SIZE_SERVER(pPacket, nLength, nBytesUsed, T_FC_DESTROY_AUCTION_MY_LIST_REQUEST,
    //         MSG_FC_DESTROY_AUCTION_MY_LIST_REQUEST, pRMsg);
    
    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå ÀÌ¿ëÁßÀÎÁö üũ
    if ( NULL == m_pCurrentBuildingNPC || BUILDINGKIND_DESTROY_AUCTION != m_pCurrentBuildingNPC->BuildingKind )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_MY_LIST_REQUEST, ERR_COMMON_INVALID_BUILDINGKIND);
        return RES_BREAK;
    }
    
//     ///////////////////////////////////////////////
//     // Æı«°æ¸Å°¡ ÁøÇàÁßÀÎÁö üũ
//     if ( FALSE == ms_pFieldIOCP->m_bDestroyAuctionInProgress )
//     {
//         SendErrorMessage(T_FC_DESTROY_AUCTION_MY_LIST_REQUEST, ERR_COUNTDOWN_NOT_ENOUGH_TIME);
//         return RES_BREAK;
//     }
    
    ///////////////////////////////////////////////
    // Æı«°æ¸ÅÀå °ü·Ã 0.2ÃÊ ÅÒ
    if ( DESTROY_AUCTION_PACKET_RECV_TICK > GetTickCount() - m_nLatelyMarketPacketRecvTick_GetRequeste )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_MY_LIST_REQUEST, ERR_INTERVAL_SYSTEM_SECOND);
        return RES_BREAK;
    }
    m_nLatelyMarketPacketRecvTick_GetRequeste = GetTickCount();
    
    ///////////////////////////////////////////////
    // ¾Æ·¹³ª ¼­¹ö üũ
    if ( TRUE == g_pFieldGlobal->IsArenaServer() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_MY_LIST_REQUEST, ERR_CANNOT_USE_ARENASERVER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // ij¸¯ÅÍ À¯È¿¼º üũ
    if ( FALSE == IsValidCharacter() )
    {
        SendErrorMessage(T_FC_DESTROY_AUCTION_MY_LIST_REQUEST, ERR_INVALID_CHARACTER);
        return RES_BREAK;
    }
    
    ///////////////////////////////////////////////
    // DB·Î ÀÔÂûÇöȲ ¿äûÇϱâ
    ms_pFieldIOCP->m_pAtumDBManager->MakeAndEnqueueQuery(QT_DestroyAuction_GetBiddingInfo, this, m_character.AccountUniqueNumber, NULL);
    
    return RES_RETURN_TRUE;
}
// end 2014-01-03 by jhseol&bckim, Æı«°æ¸ÅÀå - ÆÐŶ ¸®½Ãºê ÇÔ¼ö¼±¾ð

// 2014-01-28 by jhseol, ½Å±Ô Äù½ºÆ® ½ºÅ©¸³Æ® Ãß°¡ - ¾ÆÀÌÅÛ »ç¿ë È®ÀÎ
void CFieldIOCPSocket::CheckQuestUseItem(ItemNum_t i_nUseItemNum)
{
    mt_auto_lock mqLock(&m_mapQuest);                            // lock m_mapQuest
    mtmapQuestIndex2FieldCharacterQuest::iterator itrQuest= m_mapQuest.begin();
    for(; itrQuest != m_mapQuest.end(); itrQuest++)
    {
        CFieldCharacterQuest *pFCharQuest = &itrQuest->second;
        if (pFCharQuest->QuestState == QUEST_STATE_IN_PROGRESS)
        {
            CQuest *pQuestInfo = pFCharQuest->GetQuestInfo();
            if(pQuestInfo)
            {
                MSG_FC_QUEST_REQUEST_SUCCESS tmQuest;
                MEMSET_ZERO(&tmQuest, sizeof(MSG_FC_QUEST_REQUEST_SUCCESS));
                tmQuest.QuestIndex            = pQuestInfo->QuestIndex;
                this->CheckQuestRequestSuccessAndSendResult(pFCharQuest, &tmQuest, FALSE, 0, 0, 0, FALSE, FALSE, i_nUseItemNum);
                break;    // 2005-08-17 by cmkwon, Äù½ºÆ®¸¦ Çϳª¸¸ üũÇÏ°í ºüÁ® ³ª°£´Ù
            }
        }
    }
}
// end 2014-01-28 by jhseol, ½Å±Ô Äù½ºÆ® ½ºÅ©¸³Æ® Ãß°¡ - ¾ÆÀÌÅÛ »ç¿ë È®ÀÎ
TABLE SQL by St34lth4ng3l
Code: 
-- Table structure for td_Market
-- ----------------------------
IF EXISTS (SELECT * FROM sys.all_objects WHERE object_id = OBJECT_ID(N'[dbo].[td_Market]') AND type IN ('U'))
    DROP TABLE [dbo].[td_Market]
GO

CREATE TABLE [dbo].[td_Market] (
  [TransactionNum] bigint  IDENTITY(1,1) NOT NULL,
  [SellingItemUID] bigint  NULL,
  [AccountUID] int  NULL,
  [SellerCharUID] int  NULL,
  [TradeItemKind] tinyint  NULL,
  [ItemName] varchar(140) COLLATE SQL_Latin1_General_CP1_CI_AS  NULL,
  [ItemNum] int  NULL,
  [Count] int  NULL,
  [PrefixCodeNum] int  NULL,
  [SuffixCodeNum] int  NULL,
  [EnchantCount] tinyint  NULL,
  [ShapeItemNum] int  NULL,
  [ColorCode] int  NULL,
  [ReqMinLevel] tinyint  NULL,
  [ReqUnitKind] int  NULL,
  [RegistrationTime] datetime DEFAULT getdate() NULL,
  [TypeOfMoney] tinyint  NULL,
  [Price] int  NULL,
  [TradeStatus] tinyint  NULL,
  [BuyerUID] int DEFAULT 0 NULL,
  [BuyingTime] datetime DEFAULT 0 NULL,
  [InfluenceType] tinyint DEFAULT 0 NULL
)
GO

ALTER TABLE [dbo].[td_Market] SET (LOCK_ESCALATION = TABLE)
GO


-- ----------------------------
-- Auto increment value for td_Market
-- ----------------------------
DBCC CHECKIDENT ('[dbo].[td_Market]', RESEED, 2)
GO
If you can't see it right, I'll leave you the code in a file
Have Fun!
View attachment code.rar
 

Attachments

You must be registered for see attachments list
Last edited:
The Best DDoS Protected Servers
xxradicaldxx

xxradicaldxx

Junior Spellweaver
Joined
Sep 12, 2014
Messages
119
Reaction score
34
MORE CODE TRADE CENTER AUCTION.
POST update
Code: 
// 2013-11-25 by jhseol&bckim, 거래소 - 패킷 추가
/////////////////////////////////////////////////////////////////////////////////////////////
// T0_FC_MARKET
#define T1_FC_MARKET_BASE_INFO_REQUEST					0x00	// 초기정보 요청
#define T1_FC_MARKET_BASE_INFO_HEADER					0x01	// 초기정보 해더
#define T1_FC_MARKET_BASE_INFO_OK						0x02	// 초기정보 데이터
#define T1_FC_MARKET_BASE_INFO_DONE						0x03	// 초기정보 완료
#define T1_FC_MARKET_SEARCH_REQUEST						0x04	// 검색 요청
#define T1_FC_MARKET_SEARCH_HEADER						0x05	// 검색 해더
#define T1_FC_MARKET_SEARCH_OK							0x06	// 검색 데이터
#define T1_FC_MARKET_SEARCH_DONE						0x07	// 검색 완료
#define T1_FC_MARKET_PAGING_REQUEST						0x08	// 페이지변경 요청
#define T1_FC_MARKET_PAGING_HEADER						0x09	// 페이지변경 해더
#define T1_FC_MARKET_PAGING_OK							0x0A	// 페이지변경 데이터
#define T1_FC_MARKET_PAGING_DONE						0x0B	// 페이지변경 완료
#define T1_FC_MARKET_SORT_REQUEST						0x0C	// 정렬 요청
#define T1_FC_MARKET_SORT_HEADER						0x0D	// 정렬 해더
#define T1_FC_MARKET_SORT_OK							0x0E	// 정렬 데이터
#define T1_FC_MARKET_SORT_DONE							0x0F	// 정렬 완료
#define T1_FC_MARKET_SELL_REQUEST						0x10	// 아이템 등록 요청
#define T1_FC_MARKET_SELL_OK							0x11	// 아이템 등록 완료
#define T1_FC_MARKET_BUY_REQUEST						0x12	// 아이템 구매 요청
#define T1_FC_MARKET_BUY_OK								0x13	// 아이템 구매 완료
#define T1_FC_MARKET_GET_REQUEST						0x14	// 아이템 회수 요청
#define T1_FC_MARKET_GET_OK								0x15	// 아이템 회수 완료
#define T1_FC_MARKET_MY_LIST_REQUEST					0x16	// 판매현황 요청
#define T1_FC_MARKET_MY_LIST_HEADER						0x17	// 판매현황 해더
#define T1_FC_MARKET_MY_LIST_OK							0x18	// 판매현황 데이터
#define T1_FC_MARKET_MY_LIST_DONE						0x19	// 판매현황 완료

#define T_FC_MARKET_BASE_INFO_REQUEST	(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_BASE_INFO_REQUEST)	// C->F // 초기정보 요청
#define T_FC_MARKET_BASE_INFO_HEADER	(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_BASE_INFO_HEADER)	// F->C // 초기정보 해더
#define T_FC_MARKET_BASE_INFO_OK		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_BASE_INFO_OK)		// F->C // 초기정보 데이터
#define T_FC_MARKET_BASE_INFO_DONE		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_BASE_INFO_DONE)		// F->C // 초기정보 완료
#define T_FC_MARKET_SEARCH_REQUEST		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SEARCH_REQUEST)		// C->F // 검색 요청
#define T_FC_MARKET_SEARCH_HEADER		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SEARCH_HEADER)		// F->C // 검색 해더
#define T_FC_MARKET_SEARCH_OK			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SEARCH_OK)			// F->C // 검색 데이터
#define T_FC_MARKET_SEARCH_DONE			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SEARCH_DONE)			// F->C // 검색 완료
#define T_FC_MARKET_PAGING_REQUEST		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_PAGING_REQUEST)		// C->F // 페이지변경 요청
#define T_FC_MARKET_PAGING_HEADER		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_PAGING_HEADER)		// F->C // 페이지변경 해더
#define T_FC_MARKET_PAGING_OK			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_PAGING_OK)			// F->C // 페이지변경 데이터
#define T_FC_MARKET_PAGING_DONE			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_PAGING_DONE)			// F->C // 페이지변경 완료
#define T_FC_MARKET_SORT_REQUEST		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SORT_REQUEST)		// C->F // 정렬 요청
#define T_FC_MARKET_SORT_HEADER			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SORT_HEADER)			// F->C // 정렬 해더
#define T_FC_MARKET_SORT_OK				(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SORT_OK)				// F->C // 정렬 데이터
#define T_FC_MARKET_SORT_DONE			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SORT_DONE)			// F->C // 정렬 완료
#define T_FC_MARKET_SELL_REQUEST		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SELL_REQUEST)		// C->F // 아이템 등록 요청
#define T_FC_MARKET_SELL_OK				(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_SELL_OK)				// F->C // 아이템 등록 완료
#define T_FC_MARKET_BUY_REQUEST			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_BUY_REQUEST)			// C->F // 아이템 구매 요청
#define T_FC_MARKET_BUY_OK				(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_BUY_OK)				// F->C // 아이템 구매 완료
#define T_FC_MARKET_GET_REQUEST			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_GET_REQUEST)			// C->F // 아이템 회수 요청
#define T_FC_MARKET_GET_OK				(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_GET_OK)				// F->C // 아이템 회수 완료
#define T_FC_MARKET_MY_LIST_REQUEST		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_MY_LIST_REQUEST)		// C->F // 판매현황 요청
#define T_FC_MARKET_MY_LIST_HEADER		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_MY_LIST_HEADER)		// F->C // 판매현황 해더
#define T_FC_MARKET_MY_LIST_OK			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_MY_LIST_OK)			// F->C // 판매현황 데이터
#define T_FC_MARKET_MY_LIST_DONE		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_MARKET_MY_LIST_DONE)		// F->C // 판매현황 완료

struct MSG_FC_MARKET_SEARCH_REQUEST // 검색 요청 패킷
{
	BYTE			Kind;				// 아이템 종류(기본값 0) 0=전체
	BYTE			LevelMin;			// 레벨(기본값 0)
	BYTE			LevelMax;			// 레벨(기본값 0)
	BYTE			EnchantMin;			// 인첸트(기본값 0)
	BYTE			EnchantMax;			// 인첸트(기본값 0)
	USHORT			ItemGear;			// 사용가능 기어(기본값 0)
	BYTE			MoneyType;			// 화폐 타입(0=SPI, 1=WP)
	char			Name[MARKET_ITEM_FULL_NAME];	// 아이템 이름(접두, 접미 포함)
};

struct MSG_FC_MARKET_PAGING_REQUEST // 페이지 변경 패킷
{
	UID64_t			MarketUID;			// 제외시킬 번호(없으면 0)
	int				SelectPage;			// 선택한 페이지
};

struct MSG_FC_MARKET_SORT_REQUEST // 정렬 요청 패킷
{
	BYTE			SortingType;		// 정렬 종류
};

typedef struct 
{
	INT nSellingTime;
} MSG_FC_MARKET_BASE_INFO_HEAD;

typedef struct // 초기화, 검색, 패이징, 정렬, 판매현황 리스트 패킷
{
	MARKET_INFO MarketInfo;
} MSG_FC_MARKET_BASE_INFO_OK, MSG_FC_MARKET_SEARCH_OK, MSG_FC_MARKET_PAGING_OK, MSG_FC_MARKET_SORT_OK, MSG_FC_MARKET_MY_LIST_OK;

typedef struct // 초기화, 검색, 패이징, 정렬 완료 패킷으로 해당 결과에 따른 전체 페이지와 현제 페이지를 리턴
{
	int				ItemCount;			// 검색된 아이템의 수
	int				MaxPage;			// 전체 페이지 (페이지가 0이면 검색결과가 없다는 의미)
	int				CurrentPage;		// 보여지는 페이지
} MSG_FC_MARKET_BASE_INFO_DONE, MSG_FC_MARKET_SEARCH_DONE, MSG_FC_MARKET_PAGING_DONE, MSG_FC_MARKET_SORT_DONE;

typedef struct					// 판매현황 완료 패킷 , 입찰현황 
{
	BYTE			MyListItemCount;		// 아이템의 수
}MSG_FC_MARKET_MY_LIST_DONE,MSG_FC_DESTROY_AUCTION_MY_LIST_DONE;

struct MSG_FC_MARKET_SELL_REQUEST // 물품 등록 요청 패킷
{
	UID64_t			ItemUID;			// 아이템 고유번호
	BYTE			MoneyType;			// 화폐 타입(0=SPI, 1=WP)
	INT				Price;				// 판매금액
	INT				Count;				// 판매수량
	char			Name[MARKET_ITEM_FULL_NAME];	// 아이템 이름(접두, 접미 포함)
};

struct MSG_FC_MARKET_SELL_OK// 물품 등록 완료 패킷
{
	UID64_t			ItemUID;			// 아이템 UID
};

typedef struct // 구매, 회수 요청 및 완료 패킷
{
	UID64_t			MarketUID;			// 거래소 고유번호
}MSG_FC_MARKET_BUY_REQUEST, MSG_FC_MARKET_BUY_OK ;

typedef struct // 회수 요청
{
	UID64_t			MarketUID;			// 거래소 고유번호
	BYTE			MarketStatus;	
}MSG_FC_MARKET_GET_REQUEST,MSG_FC_MARKET_GET_OK;

struct MSG_FL_LOG_MARKET_REGISTRATION	// 게임로그 등록
{
	UID64_t				ItemUID;
	MARKET_INFO			MarketInfo;
	char *GetWriteLogString(int i_nLogType, char *o_szLogString)
	{
		sprintf(o_szLogString, "%s|%d|%d|(%I64d,%d,%d,%d,%d)|(%I64d|%I64d)\r\n", GetGameLogTypeString(i_nLogType), MarketInfo.AccountUID, MarketInfo.CharacterUID
			, ItemUID, MarketInfo.ItemNum, MarketInfo.ItemCount, MarketInfo.Price, MarketInfo.MoneyType, MarketInfo.MarketUID, MarketInfo.ItemUID);
		return o_szLogString;
	}
};
struct MSG_FL_LOG_MARKET_BUY			// 게임로그 구매
{
	UID32_t				BuyerAccountUID;
	UID32_t				BuyerCheracterUID;
	MARKET_INFO			MarketInfo;
	char *GetWriteLogString(int i_nLogType, char *o_szLogString)
	{
		sprintf(o_szLogString, "%s|%d|%d|(%d,%d,%I64d,%I64d,%d,%d,%d,%d)\r\n", GetGameLogTypeString(i_nLogType), BuyerAccountUID, BuyerCheracterUID
			, MarketInfo.AccountUID, MarketInfo.CharacterUID, MarketInfo.MarketUID, MarketInfo.ItemUID, MarketInfo.ItemNum, MarketInfo.ItemCount, MarketInfo.Price, MarketInfo.MoneyType);
		return o_szLogString;
	}
};
struct MSG_FL_LOG_MARKET_GET			// 게임로그 회수
{
	MARKET_INFO			MarketInfo;
	char *GetWriteLogString(int i_nLogType, char *o_szLogString)
	{
		sprintf(o_szLogString, "%s|%d|%d|(%I64d,%I64d,%d,%d,%d,%d,%d)\r\n", GetGameLogTypeString(i_nLogType), MarketInfo.AccountUID, MarketInfo.CharacterUID
			, MarketInfo.MarketUID, MarketInfo.ItemUID, MarketInfo.ItemNum, MarketInfo.ItemCount, MarketInfo.Price, MarketInfo.MoneyType, MarketInfo.MarketState);
		return o_szLogString;
	}
};
// end 2013-11-25 by jhseol&bckim, 거래소 - 패킷 추가

// 2014-01-03 by jhseol&bckim, 파괴경매장
/////////////////////////////////////////////////////////////////////////////////////////////
// T0_FC_MARKET 에 이어서 패킷 생성
#define T1_FC_DESTROY_AUCTION_BASE_INFO_REQUEST					0x1A	// 초기정보 요청
#define T1_FC_DESTROY_AUCTION_BASE_INFO_HEADER					0x1B	// 초기정보 해더
#define T1_FC_DESTROY_AUCTION_BASE_INFO_OK						0x1C	// 초기정보 데이터
#define T1_FC_DESTROY_AUCTION_BASE_INFO_DONE					0x1D	// 초기정보 완료
#define T1_FC_DESTROY_AUCTION_TENDER_REQUEST					0x1E	// 입찰 요청
#define T1_FC_DESTROY_AUCTION_TENDER_OK							0x1F	// 입찰 완료
#define T1_FC_DESTROY_AUCTION_GET_REQUEST						0x20	// 아이템 회수 요청
#define T1_FC_DESTROY_AUCTION_GET_OK							0x21	// 아이템 회수 완료
#define T1_FC_DESTROY_AUCTION_MY_LIST_REQUEST					0x22	// 입찰현황 요청
#define T1_FC_DESTROY_AUCTION_MY_LIST_HEADER					0x23	// 입찰현황 해더
#define T1_FC_DESTROY_AUCTION_MY_LIST_OK						0x24	// 입찰현황 데이터
#define T1_FC_DESTROY_AUCTION_MY_LIST_DONE						0x25	// 입찰현황 완료
#define T1_FC_DESTROY_AUCTION_NOTI_START						0x26	// 파괴경매 시작 알림
#define T1_FC_DESTROY_AUCTION_NOTI_END							0x27	// 파괴경매 종료 알림

#define T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST	(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_BASE_INFO_REQUEST)	// C->F // 초기정보 요청
#define T_FC_DESTROY_AUCTION_BASE_INFO_HEADER	(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_BASE_INFO_HEADER)	// F->C // 초기정보 해더
#define T_FC_DESTROY_AUCTION_BASE_INFO_OK		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_BASE_INFO_OK)		// F->C // 초기정보 데이터
#define T_FC_DESTROY_AUCTION_BASE_INFO_DONE		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_BASE_INFO_DONE)		// F->C // 초기정보 완료
#define T_FC_DESTROY_AUCTION_TENDER_REQUEST		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_TENDER_REQUEST)		// C->F // 입찰 요청
#define T_FC_DESTROY_AUCTION_TENDER_OK			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_TENDER_OK)			// F->C // 입찰 완료
#define T_FC_DESTROY_AUCTION_GET_REQUEST		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_GET_REQUEST)		// C->F // 아이템 회수 요청
#define T_FC_DESTROY_AUCTION_GET_OK				(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_GET_OK)				// F->C // 아이템 회수 완료
#define T_FC_DESTROY_AUCTION_MY_LIST_REQUEST	(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_MY_LIST_REQUEST)	// C->F // 입찰현황 요청
#define T_FC_DESTROY_AUCTION_MY_LIST_HEADER		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_MY_LIST_HEADER)		// F->C // 입찰현황 해더
#define T_FC_DESTROY_AUCTION_MY_LIST_OK			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_MY_LIST_OK)			// F->C // 입찰현황 데이터
#define T_FC_DESTROY_AUCTION_MY_LIST_DONE		(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_MY_LIST_DONE)		// F->C // 입찰현황 완료
#define T_FC_DESTROY_AUCTION_NOTI_START			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_NOTI_START)			// F->C // 파괴경매 시작 알림
#define T_FC_DESTROY_AUCTION_NOTI_END			(MessageType_t)((T0_FC_MARKET<<8)|T1_FC_DESTROY_AUCTION_NOTI_END)			// F->C // 파괴경매 종료 알림

typedef struct // 초기, 입찰현황 리스트 패킷
{
	ATUM_DATE_TIME DAuctionEndTime;
} MSG_FC_DESTROY_AUCTION_BASE_INFO_HEADER;

typedef struct // 초기, 입찰현황 리스트 패킷
{
	DESTROY_AUCTION_INFO DAuctionInfo;
} MSG_FC_DESTROY_AUCTION_BASE_INFO_OK, MSG_FC_DESTROY_AUCTION_MY_LIST_OK;

typedef struct // 입찰 요청 패킷
{
	UID64_t			DAuctionUID;			// 경매 번호
	UID32_t			AccountUID;				// 입찰자 계정 UID
	UID32_t			CharacterUID;			// 입찰자 캐릭터 UID
	INT				TenderPrice;			// 입찰 가격
}MSG_FC_DESTROY_AUCTION_TENDER_REQUEST, MSG_FC_DESTROY_AUCTION_TENDER_OK;

typedef struct // 회수 요청			// 입력정보 계정정보, 경매 고유번호, 금액, 아이템UID, 
{
	UID64_t			DAuctionUID;		// 경매 번호
	BYTE			DAuctionStatus;
	UID64_t			ItemUID;			// 아이템 고유번호
	INT				Price;
	ATUM_DATE_TIME	DAuctionGetPossibleTime;	// 회수 가능 시간(낙찰 받은(경매종료)시간이 저장된다)
}MSG_FC_DESTROY_AUCTION_GET_REQUEST,MSG_FC_DESTROY_AUCTION_GET_OK;

typedef struct			// 게임로그
{
	DESTROY_AUCTION_INFO			DAuctionInfo;
	char *GetWriteLogString(int i_nLogType, char *o_szLogString)
	{
		sprintf(o_szLogString, "%s|%d|%d|(%I64d,%I64d,%d,%d,%d,%d,%d)\r\n", GetGameLogTypeString(i_nLogType), DAuctionInfo.AccountUID, DAuctionInfo.CharacterUID
			, DAuctionInfo.DAuctionUID, DAuctionInfo.ItemUID, DAuctionInfo.ItemNum, DAuctionInfo.ItemCount, DAuctionInfo.Price, DAuctionInfo.MoneyType, DAuctionInfo.DAuctionState);
		return o_szLogString;
	}
}MSG_FL_LOG_DESTROY_AUCTION_TENDER, MSG_FL_LOG_DESTROY_AUCTION_FIX, MSG_FL_LOG_DESTROY_AUCTION_GET;		// 입찰, 낙찰, 회수
// end 2014-01-03 by jhseol&bckim, 파괴경매장
 
Last edited:
PhatLA

PhatLA

Newbie Spellweaver
Joined
Oct 21, 2020
Messages
24
Reaction score
16
Re: Tc &amp;amp;amp; auction

For who use new source like me :mellow:


Code: 
const char* GetProtocolTypeString(MessageType_t msgType)
{    
    switch (msgType)    
    {        
    case T_FC_MARKET_BASE_INFO_REQUEST:    return "T_FC_MARKET_BASE_INFO_REQUEST";          // 초기정보 요청        
    case T_FC_MARKET_BASE_INFO_HEADER:    return "T_FC_MARKET_BASE_INFO_HEADER";              // 초기정보 해더        
    case T_FC_MARKET_BASE_INFO_OK:    return "T_FC_MARKET_BASE_INFO_OK";                  // 초기정보 데이터     
    case T_FC_MARKET_BASE_INFO_DONE:    return "T_FC_MARKET_BASE_INFO_DONE";              // 초기정보 완료        
    case T_FC_MARKET_SEARCH_REQUEST:    return "T_FC_MARKET_SEARCH_REQUEST";              // 검색 요청       
    case T_FC_MARKET_SEARCH_HEADER:    return "T_FC_MARKET_SEARCH_HEADER";              // 검색 해더        
    case T_FC_MARKET_SEARCH_OK:    return "T_FC_MARKET_SEARCH_OK";                  // 검색 데이터        
    case T_FC_MARKET_SEARCH_DONE:    return "T_FC_MARKET_SEARCH_DONE";                  // 검색 완료        
    case T_FC_MARKET_PAGING_REQUEST:    return "T_FC_MARKET_PAGING_REQUEST";              // 페이지변경 요청        
    case T_FC_MARKET_PAGING_HEADER:    return "T_FC_MARKET_PAGING_HEADER";              // 페이지변경 해더        
    case T_FC_MARKET_PAGING_OK:    return "T_FC_MARKET_PAGING_OK";                  // 페이지변경 데이터        
    case T_FC_MARKET_PAGING_DONE:    return "T_FC_MARKET_PAGING_DONE";                  // 페이지변경 완료        
    case T_FC_MARKET_SORT_REQUEST:    return "T_FC_MARKET_SORT_REQUEST";                  // 정렬 요청        
    case T_FC_MARKET_SORT_HEADER:    return "T_FC_MARKET_SORT_HEADER";                     // 정렬 해더        
    case T_FC_MARKET_SORT_OK:    return "T_FC_MARKET_SORT_OK";                         // 정렬 데이터        
    case T_FC_MARKET_SORT_DONE:    return "T_FC_MARKET_SORT_DONE";                  // 정렬 완료        
    case T_FC_MARKET_SELL_REQUEST:    return "T_FC_MARKET_SELL_REQUEST";                  // 아이템 등록 요청   

    case T_FC_MARKET_SELL_OK:    return "T_FC_MARKET_SELL_OK";                         // 아이템 등록 완료        
    case T_FC_MARKET_BUY_REQUEST:    return "T_FC_MARKET_BUY_REQUEST";                     // 아이템 구매 요청        
    case T_FC_MARKET_BUY_OK:    return "T_FC_MARKET_BUY_OK";                      // 아이템 구매 완료        
    case T_FC_MARKET_GET_REQUEST:    return "T_FC_MARKET_GET_REQUEST";                     // 아이템 회수 요청        
    case T_FC_MARKET_GET_OK:    return "T_FC_MARKET_GET_OK";                      // 아이템 회수 완료        
    case T_FC_MARKET_MY_LIST_REQUEST:    return "T_FC_MARKET_MY_LIST_REQUEST";                 // 판매현황 요청        
    case T_FC_MARKET_MY_LIST_HEADER:    return "T_FC_MARKET_MY_LIST_HEADER";              // 판매현황 해더        
    case T_FC_MARKET_MY_LIST_OK:    return "T_FC_MARKET_MY_LIST_OK";                  // 판매현황 데이터        
    case T_FC_MARKET_MY_LIST_DONE:    return "T_FC_MARKET_MY_LIST_DONE";                  // 판매현황 완료                                                
    case T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST:    return "T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST"; // 초기정보 요청        
    case T_FC_DESTROY_AUCTION_BASE_INFO_HEADER:    return "T_FC_DESTROY_AUCTION_BASE_INFO_HEADER";  // 초기정보 해더        
    case T_FC_DESTROY_AUCTION_BASE_INFO_OK:    return "T_FC_DESTROY_AUCTION_BASE_INFO_OK";      // 초기정보 데이터        
    case T_FC_DESTROY_AUCTION_BASE_INFO_DONE:    return "T_FC_DESTROY_AUCTION_BASE_INFO_DONE";      // 초기정보 완료        
    case T_FC_DESTROY_AUCTION_TENDER_REQUEST:    return "T_FC_DESTROY_AUCTION_TENDER_REQUEST";      // 입찰 요청        
    case T_FC_DESTROY_AUCTION_TENDER_OK:    return "T_FC_DESTROY_AUCTION_TENDER_OK";          // 입찰 완료        
    case T_FC_DESTROY_AUCTION_GET_REQUEST:    return "T_FC_DESTROY_AUCTION_GET_REQUEST";          // 아이템 회수 요청        
    case T_FC_DESTROY_AUCTION_GET_OK:    return "T_FC_DESTROY_AUCTION_GET_OK";              // 아이템 회수 완료        
    case T_FC_DESTROY_AUCTION_MY_LIST_REQUEST:    return "T_FC_DESTROY_AUCTION_MY_LIST_REQUEST";      // 입찰현황 요청        
    case T_FC_DESTROY_AUCTION_MY_LIST_HEADER:    return "T_FC_DESTROY_AUCTION_MY_LIST_HEADER";      // 입찰현황 해더        
    case T_FC_DESTROY_AUCTION_MY_LIST_OK:    return "T_FC_DESTROY_AUCTION_MY_LIST_OK";          // 입찰현황 데이터        
    case T_FC_DESTROY_AUCTION_MY_LIST_DONE:    return "T_FC_DESTROY_AUCTION_MY_LIST_DONE";      // 입찰현황 완료        
    case T_FC_DESTROY_AUCTION_NOTI_START:     return "T_FC_DESTROY_AUCTION_NOTI_START";          // 파괴경매 시작 알림        
    case T_FC_DESTROY_AUCTION_NOTI_END:    return "T_FC_DESTROY_AUCTION_NOTI_END";          // 파괴경매 종료 알림
    }
};



Code: 
template<> struct T1<T0::enum_t::FC_MARKET>
{
     enum class enum_t : unsigned char
     {
    // 2013-11-25 by jhseol&bckim, 거래소 - 패킷 추가
    // FC_MARKET
    FC_MARKET_BASE_INFO_REQUEST                    = 0x00,    // 초기정보 요청
    FC_MARKET_BASE_INFO_HEADER                    = 0x01,    // 초기정보 해더
    FC_MARKET_BASE_INFO_OK                        = 0x02,    // 초기정보 데이터
    FC_MARKET_BASE_INFO_DONE                    = 0x03,    // 초기정보 완료
    FC_MARKET_SEARCH_REQUEST                    = 0x04,    // 검색 요청
    FC_MARKET_SEARCH_HEADER                        = 0x05,    // 검색 해더
    FC_MARKET_SEARCH_OK                            = 0x06,    // 검색 데이터
    FC_MARKET_SEARCH_DONE                        = 0x07,    // 검색 완료
    FC_MARKET_PAGING_REQUEST                    = 0x08,    // 페이지변경 요청
    FC_MARKET_PAGING_HEADER                        = 0x09,    // 페이지변경 해더
    FC_MARKET_PAGING_OK                            = 0x0A,    // 페이지변경 데이터
    FC_MARKET_PAGING_DONE                        = 0x0B,    // 페이지변경 완료
    FC_MARKET_SORT_REQUEST                        = 0x0C,    // 정렬 요청
    FC_MARKET_SORT_HEADER                        = 0x0D,    // 정렬 해더
    FC_MARKET_SORT_OK                            = 0x0E,    // 정렬 데이터
    FC_MARKET_SORT_DONE                            = 0x0F,    // 정렬 완료
    FC_MARKET_SELL_REQUEST                        = 0x10,    // 아이템 등록 요청
    FC_MARKET_SELL_OK                            = 0x11,    // 아이템 등록 완료
    FC_MARKET_BUY_REQUEST                        = 0x12,    // 아이템 구매 요청
    FC_MARKET_BUY_OK                            = 0x13,    // 아이템 구매 완료
    FC_MARKET_GET_REQUEST                        = 0x14,    // 아이템 회수 요청
    FC_MARKET_GET_OK                            = 0x15,    // 아이템 회수 완료
    FC_MARKET_MY_LIST_REQUEST                    = 0x16,    // 판매현황 요청
    FC_MARKET_MY_LIST_HEADER                    = 0x17,    // 판매현황 해더
    FC_MARKET_MY_LIST_OK                        = 0x18,    // 판매현황 데이터
    FC_MARKET_MY_LIST_DONE                        = 0x19,    // 판매현황 완료
    // 2014-01-03 by jhseol&bckim, 파괴경매장
    // FC_MARKET 에 이어서 패킷 생성
    FC_DESTROY_AUCTION_BASE_INFO_REQUEST        = 0x1A,    // 초기정보 요청             
    FC_DESTROY_AUCTION_BASE_INFO_HEADER        = 0x1B,    // 초기정보 해더
    FC_DESTROY_AUCTION_BASE_INFO_OK            = 0x1C,    // 초기정보 데이터
    FC_DESTROY_AUCTION_BASE_INFO_DONE        = 0x1D,    // 초기정보 완료
    FC_DESTROY_AUCTION_TENDER_REQUEST        = 0x1E,    // 입찰 요청
    FC_DESTROY_AUCTION_TENDER_OK                = 0x1F,    // 입찰 완료
    FC_DESTROY_AUCTION_GET_REQUEST            = 0x20,    // 아이템 회수 요청
    FC_DESTROY_AUCTION_GET_OK                = 0x21,    // 아이템 회수 완료
    FC_DESTROY_AUCTION_MY_LIST_REQUEST        = 0x22,    // 입찰현황 요청
    FC_DESTROY_AUCTION_MY_LIST_HEADER        = 0x23,    // 입찰현황 해더
    FC_DESTROY_AUCTION_MY_LIST_OK            = 0x24,    // 입찰현황 데이터
    FC_DESTROY_AUCTION_MY_LIST_DONE            = 0x25,    // 입찰현황 완료
    FC_DESTROY_AUCTION_NOTI_START            = 0x26,    // 파괴경매 시작 알림
    FC_DESTROY_AUCTION_NOTI_END                = 0x27    // 파괴경매 종료 알림
    };
};



enum : MessageType_t
{
    T_FC_MARKET_BASE_INFO_REQUEST     MakeMessageType(FC_MARKET, FC_MARKET_BASE_INFO_REQUEST),    // C->F // 초기정보 요청
    T_FC_MARKET_BASE_INFO_HEADER     MakeMessageType(FC_MARKET, FC_MARKET_BASE_INFO_HEADER),    // F->C // 초기정보 해더
    T_FC_MARKET_BASE_INFO_OK         MakeMessageType(FC_MARKET, FC_MARKET_BASE_INFO_OK),        // F->C // 초기정보 데이터
    T_FC_MARKET_BASE_INFO_DONE         MakeMessageType(FC_MARKET, FC_MARKET_BASE_INFO_DONE),        // F->C // 초기정보 완료
    T_FC_MARKET_SEARCH_REQUEST         MakeMessageType(FC_MARKET, FC_MARKET_SEARCH_REQUEST),        // C->F // 검색 요청
    T_FC_MARKET_SEARCH_HEADER         MakeMessageType(FC_MARKET, FC_MARKET_SEARCH_HEADER),        // F->C // 검색 해더
    T_FC_MARKET_SEARCH_OK             MakeMessageType(FC_MARKET, FC_MARKET_SEARCH_OK),            // F->C // 검색 데이터
    T_FC_MARKET_SEARCH_DONE             MakeMessageType(FC_MARKET, FC_MARKET_SEARCH_DONE),            // F->C // 검색 완료
    T_FC_MARKET_PAGING_REQUEST         MakeMessageType(FC_MARKET, FC_MARKET_PAGING_REQUEST),        // C->F // 페이지변경 요청
    T_FC_MARKET_PAGING_HEADER         MakeMessageType(FC_MARKET, FC_MARKET_PAGING_HEADER),        // F->C // 페이지변경 해더
    T_FC_MARKET_PAGING_OK             MakeMessageType(FC_MARKET, FC_MARKET_PAGING_OK),            // F->C // 페이지변경 데이터
    T_FC_MARKET_PAGING_DONE             MakeMessageType(FC_MARKET, FC_MARKET_PAGING_DONE),            // F->C // 페이지변경 완료
    T_FC_MARKET_SORT_REQUEST         MakeMessageType(FC_MARKET, FC_MARKET_SORT_REQUEST),        // C->F // 정렬 요청
    T_FC_MARKET_SORT_HEADER             MakeMessageType(FC_MARKET, FC_MARKET_SORT_HEADER),            // F->C // 정렬 해더
    T_FC_MARKET_SORT_OK                 MakeMessageType(FC_MARKET, FC_MARKET_SORT_OK),            // F->C // 정렬 데이터
    T_FC_MARKET_SORT_DONE             MakeMessageType(FC_MARKET, FC_MARKET_SORT_DONE),            // F->C // 정렬 완료
    T_FC_MARKET_SELL_REQUEST         MakeMessageType(FC_MARKET, FC_MARKET_SELL_REQUEST),        // C->F // 아이템 등록 요청
    T_FC_MARKET_SELL_OK                 MakeMessageType(FC_MARKET, FC_MARKET_SELL_OK),                // F->C // 아이템 등록 완료
    T_FC_MARKET_BUY_REQUEST             MakeMessageType(FC_MARKET, FC_MARKET_BUY_REQUEST),            // C->F // 아이템 구매 요청
    T_FC_MARKET_BUY_OK                 MakeMessageType(FC_MARKET, FC_MARKET_BUY_OK),                // F->C // 아이템 구매 완료
    T_FC_MARKET_GET_REQUEST             MakeMessageType(FC_MARKET, FC_MARKET_GET_REQUEST),            // C->F // 아이템 회수 요청
    T_FC_MARKET_GET_OK                 MakeMessageType(FC_MARKET, FC_MARKET_GET_OK),                // F->C // 아이템 회수 완료
    T_FC_MARKET_MY_LIST_REQUEST         MakeMessageType(FC_MARKET, FC_MARKET_MY_LIST_REQUEST),        // C->F // 판매현황 요청
    T_FC_MARKET_MY_LIST_HEADER         MakeMessageType(FC_MARKET, FC_MARKET_MY_LIST_HEADER),        // F->C // 판매현황 해더
    T_FC_MARKET_MY_LIST_OK             MakeMessageType(FC_MARKET, FC_MARKET_MY_LIST_OK),            // F->C // 판매현황 데이터
    T_FC_MARKET_MY_LIST_DONE         MakeMessageType(FC_MARKET, FC_MARKET_MY_LIST_DONE),        // F->C // 판매현황 완료
    T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST    MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_BASE_INFO_REQUEST),    // C->F // 초기정보 요청
    T_FC_DESTROY_AUCTION_BASE_INFO_HEADER    MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_BASE_INFO_HEADER),    // F->C // 초기정보 해더
    T_FC_DESTROY_AUCTION_BASE_INFO_OK        MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_BASE_INFO_OK),        // F->C // 초기정보 데이터
    T_FC_DESTROY_AUCTION_BASE_INFO_DONE        MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_BASE_INFO_DONE),        // F->C // 초기정보 완료
    T_FC_DESTROY_AUCTION_TENDER_REQUEST        MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_TENDER_REQUEST),        // C->F // 입찰 요청    T_FC_DESTROY_AUCTION_TENDER_OK            MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_TENDER_OK),            // F->C // 입찰 완료
    T_FC_DESTROY_AUCTION_GET_REQUEST        MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_GET_REQUEST),        // C->F // 아이템 회수 요청    T_FC_DESTROY_AUCTION_GET_OK                MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_GET_OK),                // F->C // 아이템 회수 완료
    T_FC_DESTROY_AUCTION_MY_LIST_REQUEST    MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_MY_LIST_REQUEST),    // C->F // 입찰현황 요청
    T_FC_DESTROY_AUCTION_MY_LIST_HEADER        MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_MY_LIST_HEADER),        // F->C // 입찰현황 해더    T_FC_DESTROY_AUCTION_MY_LIST_OK            MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_MY_LIST_OK),            // F->C // 입찰현황 데이터
    T_FC_DESTROY_AUCTION_MY_LIST_DONE        MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_MY_LIST_DONE),        // F->C // 입찰현황 완료    T_FC_DESTROY_AUCTION_NOTI_START            MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_NOTI_START),            // F->C // 파괴경매 시작 알림
    T_FC_DESTROY_AUCTION_NOTI_END            MakeMessageType(FC_MARKET, FC_DESTROY_AUCTION_NOTI_END)            // F->C // 파괴경매 종료 알림
};



Code: 
// 2013-12-05 by ymjoo 거래소 구현 스트링
#define STRMSG_C_131205_0001    "Entirety"
#define STRMSG_C_131205_0002    "Weapon"
#define STRMSG_C_131205_0003    "Standard Weapon"
#define STRMSG_C_131205_0004    "Vulcan"
#define STRMSG_C_131205_0005    "Cannon"
#define STRMSG_C_131205_0006    "Gatling"
#define STRMSG_C_131205_0007    "Rifle"
#define STRMSG_C_131205_0008    "Automatic"
#define STRMSG_C_131205_0009    "Dualist"
#define STRMSG_C_131205_0010    "Mess Drive"
#define STRMSG_C_131205_0011    "Advanced Weapon"
#define STRMSG_C_131205_0012    "Missile"
#define STRMSG_C_131205_0013    "Bundle"
#define STRMSG_C_131205_0014    "Armour"
#define STRMSG_C_131205_0015    "Veil"
#define STRMSG_C_131205_0016    "Defender"
#define STRMSG_C_131205_0017    "Guarder"
#define STRMSG_C_131205_0018    "Binder"
#define STRMSG_C_131205_0019    "Radar"
#define STRMSG_C_131205_0020    "Auxiliary Equipment"
#define STRMSG_C_131205_0021    "Infinite Accessory"
#define STRMSG_C_131205_0022    "Time limit Accessory"
#define STRMSG_C_131205_0023    "Computer"
#define STRMSG_C_131205_0024    "Engine"
#define STRMSG_C_131205_0025    "Expendables"
#define STRMSG_C_131205_0026    "Healing Kit"
#define STRMSG_C_131205_0027    "Gamble Kit"
#define STRMSG_C_131205_0028    "Enchant Card"
#define STRMSG_C_131205_0029    "Normal Card"
#define STRMSG_C_131205_0030    "Lucky Box"
#define STRMSG_C_131205_0031    "Etc."
#define STRMSG_C_131205_0032    "Ore"
#define STRMSG_C_131205_0033    "You've chosen the wrong item or the item is unavailable. "
#define STRMSG_C_131205_0034    "+%d %s Would you like to buy? \\n(Price : %s SPI) "
#define STRMSG_C_131205_0035    "+%d %s Would you like to buy? \\n(Price : %s WP) "
#define STRMSG_C_131205_0036    "(The number of items : %d)"
#define STRMSG_C_131205_0037    "It can't be registered due to the blank. "
#define STRMSG_C_131205_0038    "Would you like to register the item at the trade shop?"
#define STRMSG_C_131205_0039    "The item is now successfully registered at the trade shop. "
#define STRMSG_C_131205_0040    "It's expired."
#define STRMSG_C_131205_0041    "%dday"
#define STRMSG_C_131205_0042    "%dtime"
#define STRMSG_C_131205_0043    "%dminute"
#define STRMSG_C_131205_0044    "Less than a minute"
#define STRMSG_C_131205_0045    "\\ySold\\y"
#define STRMSG_C_131205_0046    "\\rExpired\\r"
#define STRMSG_C_131205_0047    "Would you like to recall the item registered at the trade shop?"
#define STRMSG_C_131205_0048    "Would like to recall the item which has expired?"
#define STRMSG_C_131205_0049    "Would you like to withdraw the money of sold item?\\n(Sales Charge : %s %s) "
#define STRMSG_C_131205_0050    "Please wait a few seconds and try again. "
#define STRMSG_C_131205_0051    "Selling items are recalled. "
#define STRMSG_C_131205_0052    "Expired items are recalled. "
#define STRMSG_C_131205_0053    "Selling price is withdrawn. "
#define STRMSG_C_131205_0054    "Failed to recall. Please try again. "
#define STRMSG_C_131205_0055    "Recalled"
#define STRMSG_C_131205_0056    "Money withdrawn"// END 2013-12-05 by ymjoo 거래소 구현 스트링// 2013-12-05 by ymjoo 거래소 구현 스트링
#define STRMSG_C_131206_0001    "You bought the item successfully.\\nThe item will be sent to your inventory. "
#define STRMSG_C_131206_0002    "\\y %d of War Point has decreased."// 2013-11-29 by ssjung 거래소 구현
#define STRMSG_C_131217_0001    "You have exceeded the number of items to be registered."
#define STRMSG_C_131217_0002    "It's sold out."
#define STRMSG_C_131217_0003    "You can't buy due to insufficient funds."
#define STRMSG_C_131217_0004    "You can't buy due to the maximum number of items has exceeded."
#define STRMSG_C_131217_0005    "You can't buy because of insufficient inventory space."
#define STRMSG_C_131217_0006    "You can't recall due to the maximum number of items has exceeded."
#define STRMSG_C_131217_0007    "You can't recall because of insufficient inventory space."
#define STRMSG_C_131217_0008    "Recall fees : SPI(%.1f%%), WP(%.1f%%)"
#define STRMSG_C_131217_0009    "Please update the list of items at the trade shop."// end 2013-11-29 by ssjung 거래소 구현// 2014-01-15 by ssjung 파괴 경매장 구현
#define STRMSG_C_140121_0001    "Auction finished"#define STRMSG_C_140121_0002    "Bids"
#define STRMSG_C_140121_0003    "You're bidding with the highest bidding price. "
#define STRMSG_C_140121_0004    "Bidding with the highest price"
#define STRMSG_C_140121_0005    "\\rHigher price being bid\\r"
#define STRMSG_C_140121_0006    "\\yBid was successful\\y"
#define STRMSG_C_140121_0007    "Rebidding"
#define STRMSG_C_140121_0008    "Recall the item"
#define STRMSG_C_140121_0009    "Result checked"
#define STRMSG_C_140121_0010    "\\yPrice of successful bid (%s) SPI\\y"
#define STRMSG_C_140121_0011    "There is no bidding going on right now or no item is registered."
#define STRMSG_C_140121_0012    "You can't bid due to insufficient funds. "
#define STRMSG_C_140121_0013    "You can't participate in bidding because there is no time remaining to bid. "
#define STRMSG_C_140121_0014    "You can't recall due to the term for recall has expired. "
#define STRMSG_C_140121_0015    "You can't recall the item due to  of insufficient inventory space. "
#define STRMSG_C_140121_0016    "\\rHigher price of bid was submitted\\r"// end 2014-01-15 by ssjung 파괴 경매장 구현



Code: 
switch (nRecvType)
        {
    case T_FC_MARKET_BASE_INFO_REQUEST:
        procRes = Process_FC_MARKET_BASE_INFO_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_MARKET_SEARCH_REQUEST:
        procRes = Process_FC_MARKET_SEARCH_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_MARKET_PAGING_REQUEST:
        procRes = Process_FC_MARKET_PAGING_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_MARKET_SORT_REQUEST:
        procRes = Process_FC_MARKET_SORT_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_MARKET_BUY_REQUEST:
        procRes = Process_FC_MARKET_BUY_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_MARKET_SELL_REQUEST:
        procRes = Process_FC_MARKET_SELL_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_MARKET_GET_REQUEST:
        procRes = Process_FC_MARKET_GET_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_MARKET_MY_LIST_REQUEST:
        procRes = Process_FC_MARKET_MY_LIST_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_DESTROY_AUCTION_BASE_INFO_REQUEST:
        procRes = Process_FC_DESTROY_AUCTION_BASE_INFO_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_DESTROY_AUCTION_TENDER_REQUEST:
        procRes = Process_FC_DESTROY_AUCTION_TENDER_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_DESTROY_AUCTION_GET_REQUEST:
        procRes = Process_FC_DESTROY_AUCTION_GET_REQUEST(pPacket, nLength, nBytesUsed);
    break;
    case T_FC_DESTROY_AUCTION_MY_LIST_REQUEST:
        procRes = Process_FC_DESTROY_AUCTION_MY_LIST_REQUEST(pPacket, nLength, nBytesUsed);
    break;
}:
 
xxradicaldxx

xxradicaldxx

Junior Spellweaver
Joined
Sep 12, 2014
Messages
119
Reaction score
34
Re: Tc &amp;amp;amp; auction

Thank you very much for your help
The code is being updated.
You just fill it out
Have fun!
Code: 
// 2008-01-23 by cmkwon, S_F, S_L: 장착/장착해제 게임 로그에 추가 - IDT_XXX, ITEM_DELETE_TYPE_XXX
#define IDT_GENERAL ((BYTE)0) // 일반 용도
#define IDT_EXPIRE_TIME ((BYTE)1) // 유효 시간/기간 경과
#define IDT_INVALID_ITEMNUM ((BYTE)2) // 유효하지 않은 ItemNum // 2009-11-20 by cmkwon, 소유 아이템 로딩시 유효하지 않은 아이템 처리 수정 -
#define IDT_COUNTABLEITEM_ZERO ((BYTE)3) // 카운터블 아이템 Count 0 // 2009-11-20 by cmkwon, 소유 아이템 로딩시 유효하지 않은 아이템 처리 수정 -
#define IDT_MARKET ((BYTE)4) // 2013-11-25 by jhseol&bckim, 거래소 - 거래중개소 타입 추가




#define IUT_AUCTION ((BYTE)10) // 경매 관련
#define IUT_MARKET ((BYTE)42) // 2013-11-25 by jhseol&bckim, 거래소 - 거래중개소 타입 추가



// 2013-11-25 by jhseol&bckim, 거래소 - GameLog 추가
#define T1_FL_LOG_MARKET_REGISTRATION 0x55 // 85 - 등록
#define T1_FL_LOG_MARKET_BUY 0x56 // 86 - 구매
#define T1_FL_LOG_MARKET_GET 0x57 // 87 - 회수
// end 2013-11-25 by jhseol&bckim, 거래소 - GameLog 추가



// 2013-11-25 by jhseol&bckim, 거래소 - GameLog 추가
#define T_FL_LOG_MARKET_REGISTRATION (MessageType_t)((T0_FL_LOG<<8)|T1_FL_LOG_MARKET_REGISTRATION) // 85 - 등록
#define T_FL_LOG_MARKET_BUY (MessageType_t)((T0_FL_LOG<<8)|T1_FL_LOG_MARKET_BUY) // 86 - 구매
#define T_FL_LOG_MARKET_GET (MessageType_t)((T0_FL_LOG<<8)|T1_FL_LOG_MARKET_GET) // 87 - 회수
// end 2013-11-25 by jhseol&bckim, 거래소 - GameLog 추가

#define T_FL_LOG_DELETE_CHARACTER_BY_ADMIN (MessageType_t)((T0_FL_LOG<<8)|T1_FL_LOG_DELETE_CHARACTER_BY_ADMIN) // 88 - 툴에서 캐릭터 삭제 - 2014-01-21 by jekim, 툴에서 캐릭터 삭제 가능하게 하기.

// 2014-01-03 by jhseol&bckim, 파괴경매장 - GameLog 추가
#define T_FL_LOG_DESTROY_AUCTION_TENDER (MessageType_t)((T0_FL_LOG<<8)|T1_FL_LOG_DESTROY_AUCTION_TENDER) // 89 - 입찰
#define T_FL_LOG_DESTROY_AUCTION_FIX (MessageType_t)((T0_FL_LOG<<8)|T1_FL_LOG_DESTROY_AUCTION_FIX) // 90 - 낙찰
#define T_FL_LOG_DESTROY_AUCTION_GET (MessageType_t)((T0_FL_LOG<<8)|T1_FL_LOG_DESTROY_AUCTION_GET) // 91 - 낙찰품 회수
// end 2014-01-03 by jhseol&bckim, 파괴경매장 - GameLog 추가


#define GLOG_IL_LT_MARKET 0x39 // 2013-11-25 by jhseol&bckim, 거래소 - GLog 추가



// 2014-03-20 by bckim, 거래소 GLOG 추가
#define GLOG_IL_LT_MARKET_SELLING_SPI 0x41 // 65
#define GLOG_IL_LT_MARKET_BUYING_SPI 0x42 // 66
#define GLOG_IL_LT_MARKET_SELLING_WP 0x43 // 67
#define GLOG_IL_LT_MARKET_BUYING_WP 0x44 // 68
// End. 2014-03-20 by bckim, 거래소 GLOG 추가

// 2013-11-25 by jhseol&bckim, 거래소
m_CopyMarketListPtr.clear();
m_nLatelyMarketPacketRecvTick_BuyPage = 0;
m_nLatelyMarketPacketRecvTick_SellPage = 0;
m_nLatelyMarketPacketRecvTick_MyListPage = 0;
m_nLatelyMarketPacketRecvTick_GetRequeste = 0;
m_nLatelyMarketListSortingType = 0;
// end 2013-11-25 by jhseol&bckim, 거래소
 
You must log in or register to reply here.

About Us

RaGEZONE® is a website dedicated to the development of massively multiplayer online role-playing games (MMORPGs).

Online statistics

Members online
186
Guests online
10,284
Total visitors
10,470
Totals may include hidden visitors.

Forum statistics

Threads
429,133
Messages
4,590,543
Members
280,865
Latest member
ryuzakyo
Most visitors online was 11410 , on 26 Apr 2024

RaGEZONE Sponsor

    HyperFilter
Back
Top