Yardım shop.cpp eror ve main error

#include "stdafx.h"
#include "../../libgame/include/grid.h"
#include "constants.h"
#include "utils.h"
#include "config.h"
#include "shop.h"
#include "desc.h"
#include "desc_manager.h"
#include "char.h"
#include "char_manager.h"
#include "item.h"
#include "item_manager.h"
#include "buffer_manager.h"
#include "packet.h"
#include "log.h"
#include "db.h"
#include "questmanager.h"
#include "monarch.h"
#include "mob_manager.h"
#include "locale_service.h"

/* ------------------------------------------------------------------------------------ */
CShop::CShop()
    : m_dwVnum(0), m_dwNPCVnum(0), m_pkPC(NULL)
{
    m_pGrid = M2_NEW CGrid(5, 9);
}

CShop::~CShop()
{
    TPacketGCShop pack;

    pack.header        = HEADER_GC_SHOP;
    pack.subheader    = SHOP_SUBHEADER_GC_END;
    pack.size        = sizeof(TPacketGCShop);

    Broadcast(&pack, sizeof(pack));

    GuestMapType::iterator it;

    it = m_map_guest.begin();

    while (it != m_map_guest.end())
    {
        LPCHARACTER ch = it->first;
        ch->SetShop(NULL);
        ++it;
    }

    M2_DELETE(m_pGrid);
}

void CShop::SetPCShop(LPCHARACTER ch)
{
    m_pkPC = ch;
}

bool CShop::Create(DWORD dwVnum, DWORD dwNPCVnum, TShopItemTable * pTable)
{
    /*
       if (NULL == CMobManager::instance().Get(dwNPCVnum))
       {
       sys_err("No such a npc by vnum %d", dwNPCVnum);
       return false;
       }
     */
    sys_log(0, "SHOP #%d (Shopkeeper %d)", dwVnum, dwNPCVnum);

    m_dwVnum = dwVnum;
    m_dwNPCVnum = dwNPCVnum;

    BYTE bItemCount;

    for (bItemCount = 0; bItemCount < SHOP_HOST_ITEM_MAX_NUM; ++bItemCount)
        if (0 == (pTable + bItemCount)->vnum)
            break;

    SetShopItems(pTable, bItemCount);
    return true;
}

void CShop::SetShopItems(TShopItemTable * pTable, BYTE bItemCount)
{
    if (bItemCount > SHOP_HOST_ITEM_MAX_NUM)
        return;

    m_pGrid->Clear();

    m_itemVector.resize(SHOP_HOST_ITEM_MAX_NUM);
    memset(&m_itemVector[0], 0, sizeof(SHOP_ITEM) * m_itemVector.size());

    for (int i = 0; i < bItemCount; ++i)
    {
        LPITEM pkItem = NULL;
        const TItemTable * item_table;

        if (m_pkPC)
        {
            pkItem = m_pkPC->GetItem(pTable->pos);

            if (!pkItem)
            {
                sys_err("cannot find item on pos (%d, %d) (name: %s)", pTable->pos.window_type, pTable->pos.cell, m_pkPC->GetName());
                continue;
            }

            item_table = pkItem->GetProto();
        }
        else
        {
            if (!pTable->vnum)
                continue;

            item_table = ITEM_MANAGER::instance().GetTable(pTable->vnum);
        }

        if (!item_table)
        {
            sys_err("Shop: no item table by item vnum #%d", pTable->vnum);
            continue;
        }

        int iPos;

        if (IsPCShop())
        {
            sys_log(0, "MyShop: use position %d", pTable->display_pos);
            iPos = pTable->display_pos;
        }
        else
            iPos = m_pGrid->FindBlank(1, item_table->bSize);

        if (iPos < 0)
        {
            sys_err("not enough shop window");
            continue;
        }

        if (!m_pGrid->IsEmpty(iPos, 1, item_table->bSize))
        {
            if (IsPCShop())
            {
                sys_err("not empty position for pc shop %s[%d]", m_pkPC->GetName(), m_pkPC->GetPlayerID());
            }
            else
            {
                sys_err("not empty position for npc shop");
            }
            continue;
        }

        m_pGrid->Put(iPos, 1, item_table->bSize);

        SHOP_ITEM & item = m_itemVector[iPos];

        item.pkItem = pkItem;
        item.itemid = 0;

        if (item.pkItem)
        {
            item.vnum = pkItem->GetVnum();
            item.count = pkItem->GetCount(); // PC 샵의 경우 아이템 개수는 진짜 아이템의 개수여야 한다.
            item.price = pTable->price; // 가격도 사용자가 정한대로..
            item.itemid    = pkItem->GetID();
        }
        else
        {
            item.vnum = pTable->vnum;
            item.count = pTable->count;

            if (IS_SET(item_table->dwFlags, ITEM_FLAG_COUNT_PER_1GOLD))
            {
                if (item_table->dwGold == 0)
                    item.price = item.count;
                else
                    item.price = item.count / item_table->dwGold;
            }
            else
                item.price = item_table->dwGold * item.count;
        }

        char name[36];
        snprintf(name, sizeof(name), "%-20s(#%-5d) (x %d)", item_table->szName, (int) item.vnum, item.count);

        sys_log(0, "SHOP_ITEM: %-36s PRICE %-5d", name, item.price);
        ++pTable;
    }
}

int CShop::Buy(LPCHARACTER ch, BYTE pos)
{
    if (pos >= m_itemVector.size())
    {
        sys_log(0, "Shop::Buy : invalid position %d : %s", pos, ch->GetName());
        return SHOP_SUBHEADER_GC_INVALID_POS;
    }

    sys_log(0, "Shop::Buy : name %s pos %d", ch->GetName(), pos);

    GuestMapType::iterator it = m_map_guest.find(ch);

    if (it == m_map_guest.end())
        return SHOP_SUBHEADER_GC_END;

    SHOP_ITEM& r_item = m_itemVector[pos];

    if (r_item.price <= 0)
    {
        LogManager::instance().HackLog("SHOP_BUY_GOLD_OVERFLOW", ch);
        return SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY;
    }

    LPITEM pkSelectedItem = ITEM_MANAGER::instance().Find(r_item.itemid);

    if (IsPCShop())
    {
        if (!pkSelectedItem)
        {
            sys_log(0, "Shop::Buy : Critical: This user seems to be a hacker : invalid pcshop item : BuyerPID:%d SellerPID:%d",
                    ch->GetPlayerID(),
                    m_pkPC->GetPlayerID());

            return false;
        }

        if ((pkSelectedItem->GetOwner() != m_pkPC))
        {
            sys_log(0, "Shop::Buy : Critical: This user seems to be a hacker : invalid pcshop item : BuyerPID:%d SellerPID:%d",
                    ch->GetPlayerID(),
                    m_pkPC->GetPlayerID());

            return false;
        }
    }

    DWORD dwPrice = r_item.price;

    //if (it->second)    // if other empire, price is triple
    //    dwPrice *= 3;

    if (ch->GetGold() < (int) dwPrice)
    {
        sys_log(1, "Shop::Buy : Not enough money : %s has %d, price %d", ch->GetName(), ch->GetGold(), dwPrice);
        return SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY;
    }

    LPITEM item;

    if (m_pkPC) // 피씨가 운영하는 샵은 피씨가 실제 아이템을 가지고있어야 한다.
        item = r_item.pkItem;
    else
        item = ITEM_MANAGER::instance().CreateItem(r_item.vnum, r_item.count);

    if (!item)
        return SHOP_SUBHEADER_GC_SOLD_OUT;
    /*
    if (!m_pkPC)
    {
        if (quest::CQuestManager::instance().GetEventFlag("hivalue_item_sell") == 0)
        {
            //축복의 구슬 && 만년한철 이벤트
            if (item->GetVnum() == 70024 || item->GetVnum() == 70035)
            {
                return SHOP_SUBHEADER_GC_END;
            }
        }
    }
    */
    int iEmptyPos;
    if (item->IsDragonSoul())
    {
        iEmptyPos = ch->GetEmptyDragonSoulInventory(item);
    }
    else
    {
        iEmptyPos = ch->GetEmptyInventory(item->GetSize());
    }

    if (iEmptyPos < 0)
    {
        if (m_pkPC)
        {
            sys_log(1, "Shop::Buy at PC Shop : Inventory full : %s size %d", ch->GetName(), item->GetSize());
            return SHOP_SUBHEADER_GC_INVENTORY_FULL;
        }
        else
        {
            sys_log(1, "Shop::Buy : Inventory full : %s size %d", ch->GetName(), item->GetSize());
            M2_DESTROY_ITEM(item);
            return SHOP_SUBHEADER_GC_INVENTORY_FULL;
        }
    }

    ch->PointChange(POINT_GOLD, -dwPrice, false);

    //세금 계산
    DWORD dwTax = 0;
    int iVal = 0;

    if (LC_IsYMIR() ||  LC_IsKorea())
    {
        if (0 < (iVal = quest::CQuestManager::instance().GetEventFlag("trade_tax")))
        {
            if (iVal > 100)
                iVal = 100;

            dwTax = dwPrice * iVal / 100;
            dwPrice = dwPrice - dwTax;
        }
        else
        {
            iVal = 3;
            dwTax = dwPrice * iVal / 100;
            dwPrice = dwPrice - dwTax;          
        }
    }
    else
    {
        iVal = quest::CQuestManager::instance().GetEventFlag("personal_shop");

        if (0 < iVal)
        {
            if (iVal > 100)
                iVal = 100;

            dwTax = dwPrice * iVal / 100;
            dwPrice = dwPrice - dwTax;
        }
        else
        {
            iVal = 0;
            dwTax = 0;
        }
    }

    // 상점에서 살 세금 5%
    if (!m_pkPC)
    {
        CMonarch::instance().SendtoDBAddMoney(dwTax, ch->GetEmpire(), ch);
    }

    // 군주 시스템 : 세금 징수
    if (m_pkPC)
    {
        m_pkPC->SyncQuickslot(QUICKSLOT_TYPE_ITEM, item->GetCell(), 255);

        if (item->GetVnum() == 90008 || item->GetVnum() == 90009) // VCARD
        {
            VCardUse(m_pkPC, ch, item);
            item = NULL;
        }
        else
        {
            char buf[512];

            if (item->GetVnum() >= 80003 && item->GetVnum() <= 80007)
            {
                snprintf(buf, sizeof(buf), "%s FROM: %u TO: %u PRICE: %u", item->GetName(), ch->GetPlayerID(), m_pkPC->GetPlayerID(), dwPrice);
                LogManager::instance().GoldBarLog(ch->GetPlayerID(), item->GetID(), SHOP_BUY, buf);
                LogManager::instance().GoldBarLog(m_pkPC->GetPlayerID(), item->GetID(), SHOP_SELL, buf);
            }
           
            item->RemoveFromCharacter();
            if (item->IsDragonSoul())
                item->AddToCharacter(ch, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyPos));
            else
                item->AddToCharacter(ch, TItemPos(INVENTORY, iEmptyPos));
            ITEM_MANAGER::instance().FlushDelayedSave(item);
           

            snprintf(buf, sizeof(buf), "%s %u(%s) %u %u", item->GetName(), m_pkPC->GetPlayerID(), m_pkPC->GetName(), dwPrice, item->GetCount());
            LogManager::instance().ItemLog(ch, item, "SHOP_BUY", buf);

            snprintf(buf, sizeof(buf), "%s %u(%s) %u %u", item->GetName(), ch->GetPlayerID(), ch->GetName(), dwPrice, item->GetCount());
            LogManager::instance().ItemLog(m_pkPC, item, "SHOP_SELL", buf);
        }

        r_item.pkItem = NULL;
        BroadcastUpdateItem(pos);

        m_pkPC->PointChange(POINT_GOLD, dwPrice, false);

        if (iVal > 0)
            m_pkPC->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("판매금액의 %d %% 가 세금으로 나가게됩니다"), iVal);

        CMonarch::instance().SendtoDBAddMoney(dwTax, m_pkPC->GetEmpire(), m_pkPC);
    }
    else
    {
        if (item->IsDragonSoul())
            item->AddToCharacter(ch, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyPos));
        else
            item->AddToCharacter(ch, TItemPos(INVENTORY, iEmptyPos));
        ITEM_MANAGER::instance().FlushDelayedSave(item);
        LogManager::instance().ItemLog(ch, item, "BUY", item->GetName());

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

        DBManager::instance().SendMoneyLog(MONEY_LOG_SHOP, item->GetVnum(), -dwPrice);
    }

    if (item)
        sys_log(0, "SHOP: BUY: name %s %s(x %d):%u price %u", ch->GetName(), item->GetName(), item->GetCount(), item->GetID(), dwPrice);

    ch->Save();

    return (SHOP_SUBHEADER_GC_OK);
}

bool CShop::AddGuest(LPCHARACTER ch, DWORD owner_vid, bool bOtherEmpire)
{
    if (!ch)
        return false;

    if (ch->GetExchange())
        return false;

    if (ch->GetShop())
        return false;

    ch->SetShop(this);

    m_map_guest.insert(GuestMapType::value_type(ch, bOtherEmpire));

    TPacketGCShop pack;

    pack.header        = HEADER_GC_SHOP;
    pack.subheader    = SHOP_SUBHEADER_GC_START;

    TPacketGCShopStart pack2;

    memset(&pack2, 0, sizeof(pack2));
    pack2.owner_vid = owner_vid;

    for (DWORD i = 0; i < m_itemVector.size() && i < SHOP_HOST_ITEM_MAX_NUM; ++i)
    {
        const SHOP_ITEM & item = m_itemVector[i];

        //HIVALUE_ITEM_EVENT
        //if (quest::CQuestManager::instance().GetEventFlag("hivalue_item_sell") == 0)
        //{
            //축복의 구슬 && 만년한철 이벤트
        //    if (item.vnum == 70024 || item.vnum == 70035)
        //    {              
        //        continue;
        //    }
        //}
       
        //END_HIVALUE_ITEM_EVENT
        if (m_pkPC && !item.pkItem)
            continue;

        pack2.items[i].vnum = item.vnum;

        // REMOVED_EMPIRE_PRICE_LIFT
       
        int iPriceLift = 3;
        if (g_bEmpireShopPriceTrippleDisable)
        {
            iPriceLift = 1;
        }
       
       
        if (bOtherEmpire) // no empire price penalty for pc shop
            pack2.items[i].price = item.price * iPriceLift;
        else
            pack2.items[i].price = item.price;

        pack2.items[i].count = item.count;

        if (item.pkItem)
        {
            thecore_memcpy(pack2.items[i].alSockets, item.pkItem->GetSockets(), sizeof(pack2.items[i].alSockets));
            thecore_memcpy(pack2.items[i].aAttr, item.pkItem->GetAttributes(), sizeof(pack2.items[i].aAttr));
        }
    }

    pack.size = sizeof(pack) + sizeof(pack2);

    ch->GetDesc()->BufferedPacket(&pack, sizeof(TPacketGCShop));
    ch->GetDesc()->Packet(&pack2, sizeof(TPacketGCShopStart));
    return true;
}

void CShop::RemoveGuest(LPCHARACTER ch)
{
    if (ch->GetShop() != this)
        return;

    m_map_guest.erase(ch);
    ch->SetShop(NULL);

    TPacketGCShop pack;

    pack.header        = HEADER_GC_SHOP;
    pack.subheader    = SHOP_SUBHEADER_GC_END;
    pack.size        = sizeof(TPacketGCShop);

    ch->GetDesc()->Packet(&pack, sizeof(pack));
}

void CShop::Broadcast(const void * data, int bytes)
{
    sys_log(1, "Shop::Broadcast %p %d", data, bytes);

    GuestMapType::iterator it;

    it = m_map_guest.begin();

    while (it != m_map_guest.end())
    {
        LPCHARACTER ch = it->first;

        if (ch->GetDesc())
            ch->GetDesc()->Packet(data, bytes);

        ++it;
    }
}

void CShop::BroadcastUpdateItem(BYTE pos)
{
    TPacketGCShop pack;
    TPacketGCShopUpdateItem pack2;

    TEMP_BUFFER    buf;

    pack.header        = HEADER_GC_SHOP;
    pack.subheader    = SHOP_SUBHEADER_GC_UPDATE_ITEM;
    pack.size        = sizeof(pack) + sizeof(pack2);

    pack2.pos        = pos;

    if (m_pkPC && !m_itemVector[pos].pkItem)
        pack2.item.vnum = 0;
    else
    {
        pack2.item.vnum    = m_itemVector[pos].vnum;
        if (m_itemVector[pos].pkItem)
        {
            thecore_memcpy(pack2.item.alSockets, m_itemVector[pos].pkItem->GetSockets(), sizeof(pack2.item.alSockets));
            thecore_memcpy(pack2.item.aAttr, m_itemVector[pos].pkItem->GetAttributes(), sizeof(pack2.item.aAttr));
        }
        else
        {
            memset(pack2.item.alSockets, 0, sizeof(pack2.item.alSockets));
            memset(pack2.item.aAttr, 0, sizeof(pack2.item.aAttr));
        }
    }

    pack2.item.price    = m_itemVector[pos].price;
    pack2.item.count    = m_itemVector[pos].count;

    buf.write(&pack, sizeof(pack));
    buf.write(&pack2, sizeof(pack2));

    Broadcast(buf.read_peek(), buf.size());
}

int CShop::GetNumberByVnum(DWORD dwVnum)
{
    int itemNumber = 0;

    for (DWORD i = 0; i < m_itemVector.size() && i < SHOP_HOST_ITEM_MAX_NUM; ++i)
    {
        const SHOP_ITEM & item = m_itemVector[i];

        if (item.vnum == dwVnum)
        {
            itemNumber += item.count;
        }
    }

    return itemNumber;
}
virtual bool CShop::IsSellingItem(DWORD itemID)
{
    //bool isSelling = false;

    for (DWORD i = 0; i < m_itemVector.size() && i < SHOP_HOST_ITEM_MAX_NUM; ++i)
    {
        if (m_itemVector[i].itemid == itemID);
        {
            isSelling = true;
            break;
        }
    }

    return isSelling;

}

#include "stdafx.h"
#include "Config.h"
#include "Peer.h"
#include "DBManager.h"
#include "ClientManager.h"
#include "GuildManager.h"
#include "ItemAwardManager.h"
#include "HB.h"
#include "PrivManager.h"
#include "MoneyLog.h"
#include "Marriage.h"
#include "Monarch.h"
#include "BlockCountry.h"
#include "ItemIDRangeManager.h"
#ifdef __AUCTION__
#include "AuctionManager.h"
#endif
#include <signal.h>

void SetPlayerDBName(const char* c_pszPlayerDBName);
void SetTablePostfix(const char* c_pszTablePostfix);
int Start();

std::string g_stTablePostfix;
std::string g_stLocaleNameColumn = "name";
std::string g_stLocale = "latin1";
std::string g_stPlayerDBName = "";


bool g_bHotBackup = false;
BOOL g_test_server = false;

//���� ��
int g_iPlayerCacheFlushSeconds = 60*7;
int g_iItemCacheFlushSeconds = 60*5;

//g_iLogoutSeconds ��ġ�� g_iPlayerCacheFlushSeconds �� g_iItemCacheFlushSeconds ���� ���� �Ѵ�.
int g_iLogoutSeconds = 60*10;

int g_log = 1;


// MYSHOP_PRICE_LIST
int g_iItemPriceListTableCacheFlushSeconds = 540;
// END_OF_MYSHOP_PRICE_LIST

#ifdef __FreeBSD__
extern const char * _malloc_options;
#endif

extern void WriteVersion();

void emergency_sig(int sig)
{
    if (sig == SIGSEGV)
        sys_log(0, "SIGNAL: SIGSEGV");
    else if (sig == SIGUSR1)
        sys_log(0, "SIGNAL: SIGUSR1");

    if (sig == SIGSEGV)
        abort();
}

int main()
{
    WriteVersion();

#ifdef __FreeBSD__
    _malloc_options = "A";
#endif

    CConfig Config;
    CNetPoller poller;
    CDBManager DBManager;
    CClientManager ClientManager;
    PlayerHB player_hb;
    CGuildManager GuildManager;
    CPrivManager PrivManager;
    CMoneyLog MoneyLog;
    ItemAwardManager ItemAwardManager;
    marriage::CManager MarriageManager;
    CMonarch Monarch;
    CBlockCountry    BlockCountry;
    CItemIDRangeManager ItemIDRangeManager;
#ifdef __AUCTION__
    AuctionManager auctionManager;
#endif
    if (!Start())
        return 1;

    GuildManager.Initialize();
    MarriageManager.Initialize();
    BlockCountry.Load();
    ItemIDRangeManager.Build();
#ifdef __AUCTION__
    AuctionManager::instance().Initialize();
#endif
    sys_log(0, "Metin2DBCacheServer Start\n");

    CClientManager::instance().MainLoop();

    signal_timer_disable();

    DBManager.Quit();
    int iCount;

    while (1)
    {
        iCount = 0;

        iCount += CDBManager::instance().CountReturnQuery(SQL_PLAYER);
        iCount += CDBManager::instance().CountAsyncQuery(SQL_PLAYER);

        if (iCount == 0)
            break;

        usleep(1000);
        sys_log(0, "WAITING_QUERY_COUNT %d", iCount);
    }

    return 1;
}

void emptybeat(LPHEART heart, int pulse)
{
    if (!(pulse % heart->passes_per_sec))    // 1�ʿ� �ѹ�
    {
    }
}

//
// @version    05/06/13 Bang2ni - ������ �������� ij�� flush timeout ���� �߰�.
//
int Start()
{
    if (!CConfig::instance().LoadFile("conf.txt"))
    {
        fprintf(stderr, "Loading conf.txt failed.\n");
        return false;
    }

    if (!CConfig::instance().GetValue("TEST_SERVER", &g_test_server))
    {
        fprintf(stderr, "Real Server\n");
    }
    else
        fprintf(stderr, "Test Server\n");

    if (!CConfig::instance().GetValue("LOG", &g_log))
    {
        fprintf(stderr, "Log Off");
        g_log= 0;
    }
    else
    {
        g_log = 1;
        fprintf(stderr, "Log On");       
    }

    
    
    int tmpValue;

    int heart_beat = 50;
    if (!CConfig::instance().GetValue("CLIENT_HEART_FPS", &heart_beat))
    {
        fprintf(stderr, "Cannot find CLIENT_HEART_FPS configuration.\n");
        return false;
    }

    log_set_expiration_days(3);

    if (CConfig::instance().GetValue("LOG_KEEP_DAYS", &tmpValue))
    {
        tmpValue = MINMAX(3, tmpValue, 30);
        log_set_expiration_days(tmpValue);
        fprintf(stderr, "Setting log keeping days to %d\n", tmpValue);
    }

    thecore_init(heart_beat, emptybeat);
    signal_timer_enable(60);

    char szBuf[256+1];

    if (CConfig::instance().GetValue("LOCALE", szBuf, 256))
    {
        g_stLocale = szBuf;
        sys_log(0, "LOCALE set to %s", g_stLocale.c_str());

        // CHINA_DISABLE_HOTBACKUP
        if ("gb2312" == g_stLocale)
        {
            sys_log(0, "CIBN_LOCALE: DISABLE_HOTBACKUP");
            g_bHotBackup = false;
        }
        // END_OF_CHINA_DISABLE_HOTBACKUP
    }

    int iDisableHotBackup;
    if (CConfig::instance().GetValue("DISABLE_HOTBACKUP", &iDisableHotBackup))
    {
        if (iDisableHotBackup)
        {   
            sys_log(0, "CONFIG: DISABLE_HOTBACKUP");
            g_bHotBackup = false;
        }
    }

    if (!CConfig::instance().GetValue("TABLE_POSTFIX", szBuf, 256))
    {
        sys_err("TABLE_POSTFIX not configured use default");
        szBuf[0] = '\0';
    }

    SetTablePostfix(szBuf);

    if (CConfig::instance().GetValue("PLAYER_CACHE_FLUSH_SECONDS", szBuf, 256))
    {
        str_to_number(g_iPlayerCacheFlushSeconds, szBuf);
        sys_log(0, "PLAYER_CACHE_FLUSH_SECONDS: %d", g_iPlayerCacheFlushSeconds);
    }

    if (CConfig::instance().GetValue("ITEM_CACHE_FLUSH_SECONDS", szBuf, 256))
    {
        str_to_number(g_iItemCacheFlushSeconds, szBuf);
        sys_log(0, "ITEM_CACHE_FLUSH_SECONDS: %d", g_iItemCacheFlushSeconds);
    }

    // MYSHOP_PRICE_LIST
    if (CConfig::instance().GetValue("ITEM_PRICELIST_CACHE_FLUSH_SECONDS", szBuf, 256))
    {
        str_to_number(g_iItemPriceListTableCacheFlushSeconds, szBuf);
        sys_log(0, "ITEM_PRICELIST_CACHE_FLUSH_SECONDS: %d", g_iItemPriceListTableCacheFlushSeconds);
    }
    // END_OF_MYSHOP_PRICE_LIST
    //
    if (CConfig::instance().GetValue("CACHE_FLUSH_LIMIT_PER_SECOND", szBuf, 256))
    {
        DWORD dwVal = 0; str_to_number(dwVal, szBuf);
        CClientManager::instance().SetCacheFlushCountLimit(dwVal);
    }

    int iIDStart;
    if (!CConfig::instance().GetValue("PLAYER_ID_START", &iIDStart))
    {
        sys_err("PLAYER_ID_START not configured");
        return false;
    }

    CClientManager::instance().SetPlayerIDStart(iIDStart);

    if (CConfig::instance().GetValue("NAME_COLUMN", szBuf, 256))
    {
        fprintf(stderr, "%s %s", g_stLocaleNameColumn.c_str(), szBuf);
        g_stLocaleNameColumn = szBuf;
    }

    char szAddr[64], szDB[64], szUser[64], szPassword[64];
    int iPort;
    char line[256+1];

    if (CConfig::instance().GetValue("SQL_PLAYER", line, 256))
    {
        sscanf(line, " %s %s %s %s %d ", szAddr, szDB, szUser, szPassword, &iPort);
        sys_log(0, "connecting to MySQL server (player)");

        int iRetry = 5;

        do
        {
            if (CDBManager::instance().Connect(SQL_PLAYER, szAddr, iPort, szDB, szUser, szPassword))
            {
                sys_log(0, "   OK");
                break;
            }

            sys_log(0, "   failed, retrying in 5 seconds");
            fprintf(stderr, "   failed, retrying in 5 seconds");
            sleep(5);
        } while (iRetry--);
        fprintf(stderr, "Success PLAYER\n");
        SetPlayerDBName(szDB);
    }
    else
    {
        sys_err("SQL_PLAYER not configured");
        return false;
    }

    if (CConfig::instance().GetValue("SQL_ACCOUNT", line, 256))
    {
        sscanf(line, " %s %s %s %s %d ", szAddr, szDB, szUser, szPassword, &iPort);
        sys_log(0, "connecting to MySQL server (account)");

        int iRetry = 5;

        do
        {
            if (CDBManager::instance().Connect(SQL_ACCOUNT, szAddr, iPort, szDB, szUser, szPassword))
            {
                sys_log(0, "   OK");
                break;
            }

            sys_log(0, "   failed, retrying in 5 seconds");
            fprintf(stderr, "   failed, retrying in 5 seconds");
            sleep(5);
        } while (iRetry--);
        fprintf(stderr, "Success ACCOUNT\n");
    }
    else
    {
        sys_err("SQL_ACCOUNT not configured");
        return false;
    }

    if (CConfig::instance().GetValue("SQL_COMMON", line, 256))
    {
        sscanf(line, " %s %s %s %s %d ", szAddr, szDB, szUser, szPassword, &iPort);
        sys_log(0, "connecting to MySQL server (common)");

        int iRetry = 5;

        do
        {
            if (CDBManager::instance().Connect(SQL_COMMON, szAddr, iPort, szDB, szUser, szPassword))
            {
                sys_log(0, "   OK");
                break;
            }

            sys_log(0, "   failed, retrying in 5 seconds");
            fprintf(stderr, "   failed, retrying in 5 seconds");
            sleep(5);
        } while (iRetry--);
        fprintf(stderr, "Success COMMON\n");
    }
    else
    {
        sys_err("SQL_COMMON not configured");
        return false;
    }

    
    {
        if (CConfig::instance().GetValue("SQL_HOTBACKUP", line, 256))
        {
            sscanf(line, " %s %s %s %s %d ", szAddr, szDB, szUser, szPassword, &iPort);
            sys_log(0, "connecting to MySQL server (hotbackup)");

            int iRetry = 5;

            do
            {
                if (CDBManager::instance().Connect(SQL_HOTBACKUP, szAddr, iPort, szDB, szUser, szPassword))
                {
                    sys_log(0, "   OK");
                    break;
                }

                sys_log(0, "   failed, retrying in 5 seconds");
                fprintf(stderr, "   failed, retrying in 5 seconds");
                sleep(5);
            }
            while (iRetry--);

            fprintf(stderr, "Success HOTBACKUP\n");
        }
        else
        {
            sys_err("SQL_HOTBACKUP not configured");
            return false;
        }
    
    if (!CNetPoller::instance().Create())
    {
        sys_err("Cannot create network poller");
        return false;
    }

    sys_log(0, "ClientManager initialization.. ");

    if (!CClientManager::instance().Initialize())
    {
        sys_log(0, "   failed");
        return false;
    }

    sys_log(0, "   OK");

    if (!PlayerHB::instance().Initialize())
    {
        sys_err("cannot initialize player hotbackup");
        return false;
    }


#ifndef __WIN32__
    signal(SIGUSR1, emergency_sig);
#endif
    signal(SIGSEGV, emergency_sig);
    return true;

{
void SetTablePostfix(const char* c_pszTablePostfix)
{
    if (!c_pszTablePostfix || !*c_pszTablePostfix)
        g_stTablePostfix = "";
    else
        g_stTablePostfix = c_pszTablePostfix;
}
}

const char * GetTablePostfix()
{
    return g_stTablePostfix.c_str();
}

void SetPlayerDBName(const char* c_pszPlayerDBName)
{
    if (! c_pszPlayerDBName || ! *c_pszPlayerDBName)
        g_stPlayerDBName = "";
    else
    {
        g_stPlayerDBName = c_pszPlayerDBName;
        g_stPlayerDBName += ".";
    }
}

const char * GetPlayerDBName()
{
    return g_stPlayerDBName.c_str();
}