#include "StdAfx.h"
#include "ServerListManager.h"
#include "ServiceUnits.h"
//////////////////////////////////////////////////////////////////////////////////

//构造函数
CGameTypeItem::CGameTypeItem()
{
    //设置变量
    ZeroMemory(&m_GameType, sizeof(m_GameType));

    return;
}

//////////////////////////////////////////////////////////////////////////////////

//构造函数
CGameKindItem::CGameKindItem()
{
    //设置变量
    ZeroMemory(&m_GameKind, sizeof(m_GameKind));

    return;
}

//////////////////////////////////////////////////////////////////////////////////

//构造函数
CGameNodeItem::CGameNodeItem()
{
    //设置变量
    ZeroMemory(&m_GameNode, sizeof(m_GameNode));

    return;
}

//////////////////////////////////////////////////////////////////////////////////

//构造函数
CGameServerItem::CGameServerItem()
{
    //设置变量
    ZeroMemory(&m_GameServer, sizeof(m_GameServer));

    return;
}

//////////////////////////////////////////////////////////////////////////////////


//获取随机链路
std::wstring  CGameServerItem::GetRandom(DWORD dUserID, int iPaiMing, int iCount)
{
	std::wstring cc = L"";

	CList<std::wstring> aa;

	for (size_t i = 0; i < MAX_TONGDAO; i++)
	{
		if (m_ListLL[i].iIsOk == 1)
		{
			std::wstring bb = m_ListLL[i].szIP;
			aa.AddTail(bb);
		}
	}

	if (aa.GetCount() == 0) return cc;

	int iNum = aa.GetCount();

	double dPaiMing = ((double)iPaiMing) / ((double)iCount) * ((double)iNum);
	int iKey = (int)dPaiMing;

	if (iKey > iNum) iKey = iNum;
	cc = aa.GetAt(aa.FindIndex(iKey));

	TCHAR szString[512] = TEXT("");
	ZeroMemory(szString, sizeof(TCHAR) * 512);
	_sntprintf(szString, CountArray(szString), TEXT("通道信息 总通道数->%d 排名:%d 最大排名:%d 取通道ID：%d")
		, aa.GetCount(), iPaiMing, iCount, iKey);

	aa.RemoveAll();

	if (CServiceUnits::g_pServiceUnits->m_AttemperEngineSink.IsJC(1314))
	{
		//提示消息
		CTraceService::TraceString(szString, TraceLevel_Normal);
	}

	return cc;
}


//更新链路状态
bool CGameServerItem::SetLLStat(std::wstring szIp, int iStat, SYSTEMTIME Time)
{
	bool bFind = false;
	for (size_t i = 0; i < MAX_TONGDAO; i++)
	{
		std::wstring test = m_ListLL[i].szIP;

		if (test == szIp)
		{
			m_ListLL[i].iIsOk = iStat;
			m_ListLL[i].SystemTimeConclude = Time;
			bFind = true;
			//break;
		}
	}

	if (bFind) return true;

	for (size_t i = 0; i < MAX_TONGDAO; i++)
	{
		std::wstring test = m_ListLL[i].szIP;
		if (test == _T(""))
		{
			StringCbCat(m_ListLL[i].szIP, 32, szIp.c_str());
			m_ListLL[i].iIsOk = iStat;
			m_ListLL[i].SystemTimeConclude = Time;
			break;
		}
	}
	return true;
}
//////////////////////////////////////////////////////////////////////////////////

//构造函数
CGamePageItem::CGamePageItem()
{
    //设置变量
    ZeroMemory(&m_GamePage, sizeof(m_GamePage));

    return;
}

//////////////////////////////////////////////////////////////////////////////////

//构造函数
CServerListManager::CServerListManager()
{
    //设置质数
    m_TypeItemMap.InitHashTable(PRIME_TYPE);
    m_KindItemMap.InitHashTable(PRIME_KIND);
    m_NodeItemMap.InitHashTable(PRIME_NODE);
    m_PageItemMap.InitHashTable(PRIME_PAGE);
    m_ServerItemMap.InitHashTable(PRIME_SERVER);

    return;
}

//析构函数
CServerListManager::~CServerListManager()
{
    //变量定义
    WORD wKey = 0;

    //删除种类
    CGameTypeItem * pGameTypeItem = NULL;
    POSITION Position = m_TypeItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_TypeItemMap.GetNextAssoc(Position, wKey, pGameTypeItem);
        SafeDelete(pGameTypeItem);
    }
    for (INT_PTR i = 0; i < m_TypeItemBuffer.GetCount(); i++)
    {
        pGameTypeItem = m_TypeItemBuffer[i];
        SafeDelete(pGameTypeItem);
    }
    m_TypeItemMap.RemoveAll();
    m_TypeItemBuffer.RemoveAll();

    //删除类型
    CGameKindItem * pGameKindItem = NULL;
    Position = m_KindItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_KindItemMap.GetNextAssoc(Position, wKey, pGameKindItem);
        SafeDelete(pGameKindItem);
    }
    for (INT_PTR i = 0; i < m_KindItemBuffer.GetCount(); i++)
    {
        pGameKindItem = m_KindItemBuffer[i];
        SafeDelete(pGameKindItem);
    }
    m_KindItemMap.RemoveAll();
    m_KindItemBuffer.RemoveAll();

    //删除节点
    CGameNodeItem * pGameNodeItem = NULL;
    Position = m_NodeItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_NodeItemMap.GetNextAssoc(Position, wKey, pGameNodeItem);
        SafeDelete(pGameNodeItem);
    }
    for (INT_PTR i = 0; i < m_NodeItemBuffer.GetCount(); i++)
    {
        pGameNodeItem = m_NodeItemBuffer[i];
        SafeDelete(pGameNodeItem);
    }
    m_NodeItemMap.RemoveAll();
    m_NodeItemBuffer.RemoveAll();

    //删除房间
    CGameServerItem * pGameServerItem = NULL;
    Position = m_ServerItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_ServerItemMap.GetNextAssoc(Position, wKey, pGameServerItem);
        SafeDelete(pGameServerItem);
    }
    for (INT_PTR i = 0; i < m_ServerItemBuffer.GetCount(); i++)
    {
        pGameServerItem = m_ServerItemBuffer[i];
        SafeDelete(pGameServerItem);
    }
    m_ServerItemMap.RemoveAll();
    m_ServerItemBuffer.RemoveAll();

    //删除定制
    CGamePageItem * pGamePageItem = NULL;
    Position = m_PageItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_PageItemMap.GetNextAssoc(Position, wKey, pGamePageItem);
        SafeDelete(pGamePageItem);
    }
    for (INT_PTR i = 0; i < m_PageItemBuffer.GetCount(); i++)
    {
        pGamePageItem = m_PageItemBuffer[i];
        SafeDelete(pGamePageItem);
    }
    m_PageItemMap.RemoveAll();
    m_PageItemBuffer.RemoveAll();

    return;
}

//重置列表
VOID CServerListManager::ResetServerList()
{
    //废弃列表
    DisuseKernelItem();
    DisuseServerItem();

    //清理列表
    CleanKernelItem();
    CleanServerItem();

    return;
}

//清理内核
VOID CServerListManager::CleanKernelItem()
{
    //变量定义
    POSITION PositionType = m_TypeItemMap.GetStartPosition();
    POSITION PositionKind = m_KindItemMap.GetStartPosition();
    POSITION PositionNode = m_NodeItemMap.GetStartPosition();
    POSITION PositionPage = m_PageItemMap.GetStartPosition();

    //清理种类
    while (PositionType != NULL)
    {
        //索引房间
        WORD wTypeID = 0;
        CGameTypeItem * pGameTypeItem = NULL;
        m_TypeItemMap.GetNextAssoc(PositionType, wTypeID, pGameTypeItem);

        //删除判断
        if (pGameTypeItem->m_bDisuse == true)
        {
            m_TypeItemMap.RemoveKey(wTypeID);
            m_TypeItemBuffer.Add(pGameTypeItem);
        }
    }

    //清理类型
    while (PositionKind != NULL)
    {
        //索引房间
        WORD wKindID = 0;
        CGameKindItem * pGameKindItem = NULL;
        m_KindItemMap.GetNextAssoc(PositionKind, wKindID, pGameKindItem);

        //删除判断
        if (pGameKindItem->m_bDisuse == true)
        {
            m_KindItemMap.RemoveKey(wKindID);
            m_KindItemBuffer.Add(pGameKindItem);
        }
    }

    //清理节点
    while (PositionNode != NULL)
    {
        //索引房间
        WORD wNodeID = 0;
        CGameNodeItem * pGameNodeItem = NULL;
        m_NodeItemMap.GetNextAssoc(PositionNode, wNodeID, pGameNodeItem);

        //删除判断
        if (pGameNodeItem->m_bDisuse == true)
        {
            m_NodeItemMap.RemoveKey(wNodeID);
            m_NodeItemBuffer.Add(pGameNodeItem);
        }
    }

    //清理定制
    while (PositionPage != NULL)
    {
        //索引房间
        WORD wPageID = 0;
        CGamePageItem * pGamePageItem = NULL;
        m_PageItemMap.GetNextAssoc(PositionPage, wPageID, pGamePageItem);

        //删除判断
        if (pGamePageItem->m_bDisuse == true)
        {
            m_PageItemMap.RemoveKey(wPageID);
            m_PageItemBuffer.Add(pGamePageItem);
        }
    }

    return;
}

//清理房间
VOID CServerListManager::CleanServerItem()
{
    //变量定义
    POSITION PositionServer = m_ServerItemMap.GetStartPosition();

    //删除房间
    while (PositionServer != NULL)
    {
        //索引房间
        WORD wServerID = 0;
        CGameServerItem * pGameServerItem = NULL;
        m_ServerItemMap.GetNextAssoc(PositionServer, wServerID, pGameServerItem);

        //删除判断
        if (pGameServerItem->m_bDisuse == true)
        {
            //删除数据
            m_ServerItemMap.RemoveKey(wServerID);
            m_ServerItemBuffer.Add(pGameServerItem);

            //设置人数
            CGameKindItem * pGameKindItem = NULL;
            if (m_KindItemMap.Lookup(pGameServerItem->m_GameServer.wKindID, pGameKindItem) == TRUE)
            {
                tagGameServer * pGameServer = &pGameServerItem->m_GameServer;
                pGameKindItem->m_GameKind.dwOnLineCount -= pGameServer->dwOnLineCount;
                pGameKindItem->m_GameKind.dwFullCount -= pGameServer->dwFullCount;
            }
        }
    }

    return;
}

//废弃内核
VOID CServerListManager::DisuseKernelItem()
{
    //变量定义
    WORD wKey = 0;
    DWORD dwKey = 0;

    //废弃种类
    CGameTypeItem * pGameTypeItem = NULL;
    POSITION Position = m_TypeItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_TypeItemMap.GetNextAssoc(Position, wKey, pGameTypeItem);
        pGameTypeItem->m_bDisuse = true;
    }

    //废弃类型
    CGameKindItem * pGameKindItem = NULL;
    Position = m_KindItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_KindItemMap.GetNextAssoc(Position, wKey, pGameKindItem);
        pGameKindItem->m_bDisuse = true;
    }

    //废弃节点
    CGameNodeItem * pGameNodeItem = NULL;
    Position = m_NodeItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_NodeItemMap.GetNextAssoc(Position, wKey, pGameNodeItem);
        pGameNodeItem->m_bDisuse = true;
    }

    //废弃定制
    CGamePageItem * pGamePageItem = NULL;
    Position = m_PageItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_PageItemMap.GetNextAssoc(Position, wKey, pGamePageItem);
        pGamePageItem->m_bDisuse = true;
    }

    return;
}

//废弃房间
VOID CServerListManager::DisuseServerItem()
{
    //变量定义
    WORD wKey = 0;
    CGameServerItem * pGameServerItem = NULL;

    //废弃房间
    POSITION Position = m_ServerItemMap.GetStartPosition();
    while (Position != NULL)
    {
        m_ServerItemMap.GetNextAssoc(Position, wKey, pGameServerItem);
        pGameServerItem->m_bDisuse = true;
    }

    return;
}

//统计人数
DWORD CServerListManager::CollectOnlineInfo()
{
    //变量定义
    DWORD dwOnLineCount = 0L;
    POSITION PositionKind = m_KindItemMap.GetStartPosition();

    //统计人数
    while (PositionKind != NULL)
    {
        //索引类型
        WORD wKindID = 0;
        CGameKindItem * pGameKindItem = NULL;
        m_KindItemMap.GetNextAssoc(PositionKind, wKindID, pGameKindItem);

        //统计人数
        if (pGameKindItem != NULL) dwOnLineCount += pGameKindItem->m_GameKind.dwOnLineCount;
    }

    return dwOnLineCount;
}

//类型在线
DWORD CServerListManager::CollectOnlineInfo(WORD wKindID)
{
    //变量定义
    DWORD dwOnLineCount = 0L;
    POSITION PositionServer = m_ServerItemMap.GetStartPosition();

    //枚举房间
    while (PositionServer != NULL)
    {
        //索引房间
        WORD wServerID = 0;
        CGameServerItem * pGameServerItem = NULL;
        m_ServerItemMap.GetNextAssoc(PositionServer, wServerID, pGameServerItem);

        //统计人数
        if (pGameServerItem->m_GameServer.wKindID == wKindID)
        {
            dwOnLineCount += pGameServerItem->m_GameServer.dwOnLineCount;
        }
    }

    return dwOnLineCount;
}

//插入种类
bool CServerListManager::InsertGameType(tagGameType * pGameType)
{
    //效验参数
    ASSERT(pGameType != NULL);
    if (pGameType == NULL) return false;

    //查找现存
    CGameTypeItem * pGameTypeItem = NULL;
    if (m_TypeItemMap.Lookup(pGameType->wTypeID, pGameTypeItem) == FALSE)
    {
        //创建对象
        try
        {
            INT_PTR nStroeCount = m_TypeItemBuffer.GetCount();
            if (nStroeCount > 0)
            {
                pGameTypeItem = m_TypeItemBuffer[nStroeCount - 1];
                m_TypeItemBuffer.RemoveAt(nStroeCount - 1);
            }
            else
            {
                pGameTypeItem = new CGameTypeItem;
                if (pGameTypeItem == NULL) return false;
            }
        }
        catch (...) { return false; }

        //设置变量
        ZeroMemory(pGameTypeItem, sizeof(CGameTypeItem));
    }

    //设置数据
    pGameTypeItem->m_bDisuse = false;
    CopyMemory(&pGameTypeItem->m_GameType, pGameType, sizeof(tagGameType));

    //设置索引
    m_TypeItemMap[pGameType->wTypeID] = pGameTypeItem;

    return true;
}

//插入类型
bool CServerListManager::InsertGameKind(tagGameKind * pGameKind)
{
    //效验参数
    ASSERT(pGameKind != NULL);
    if (pGameKind == NULL) return false;

    //查找现存
    CGameKindItem * pGameKindItem = NULL;
    if (m_KindItemMap.Lookup(pGameKind->wKindID, pGameKindItem) == FALSE)
    {
        //创建对象
        try
        {
            INT_PTR nStroeCount = m_KindItemBuffer.GetCount();
            if (nStroeCount > 0)
            {
                pGameKindItem = m_KindItemBuffer[nStroeCount - 1];
                m_KindItemBuffer.RemoveAt(nStroeCount - 1);
            }
            else
            {
                pGameKindItem = new CGameKindItem;
                if (pGameKindItem == NULL) return false;
            }
        }
        catch (...) { return false; }

        //设置变量
        ZeroMemory(pGameKindItem, sizeof(CGameKindItem));
    }

    //设置数据
    pGameKindItem->m_bDisuse = false;
    CopyMemory(&pGameKindItem->m_GameKind, pGameKind, sizeof(tagGameKind));

    //设置索引
    m_KindItemMap[pGameKind->wKindID] = pGameKindItem;

    return true;
}

//插入节点
bool CServerListManager::InsertGameNode(tagGameNode * pGameNode)
{
    //效验参数
    ASSERT(pGameNode != NULL);
    if (pGameNode == NULL) return false;

    //查找现存
    CGameNodeItem * pGameNodeItem = NULL;
    if (m_NodeItemMap.Lookup(pGameNode->wNodeID, pGameNodeItem) == FALSE)
    {
        //创建对象
        try
        {
            INT_PTR nStroeCount = m_NodeItemBuffer.GetCount();
            if (nStroeCount > 0)
            {
                pGameNodeItem = m_NodeItemBuffer[nStroeCount - 1];
                m_NodeItemBuffer.RemoveAt(nStroeCount - 1);
            }
            else
            {
                pGameNodeItem = new CGameNodeItem;
                if (pGameNodeItem == NULL) return false;
            }
        }
        catch (...) { return false; }

        //设置变量
        ZeroMemory(pGameNodeItem, sizeof(CGameNodeItem));
    }

    //插入数据
    pGameNodeItem->m_bDisuse = false;
    CopyMemory(&pGameNodeItem->m_GameNode, pGameNode, sizeof(tagGameNode));

    //设置索引
    m_NodeItemMap[pGameNode->wNodeID] = pGameNodeItem;

    return true;
}

//插入定制
bool CServerListManager::InsertGamePage(tagGamePage * pGamePage)
{
    //效验参数
    ASSERT(pGamePage != NULL);
    if (pGamePage == NULL) return false;

    //获取子项
    CGamePageItem * pGamePageItem = NULL;
    if (m_PageItemMap.Lookup(pGamePage->wPageID, pGamePageItem) == FALSE)
    {
        //创建对象
        try
        {
            INT_PTR nStroeCount = m_PageItemBuffer.GetCount();
            if (nStroeCount > 0)
            {
                pGamePageItem = m_PageItemBuffer[nStroeCount - 1];
                m_PageItemBuffer.RemoveAt(nStroeCount - 1);
            }
            else
            {
                pGamePageItem = new CGamePageItem;
                if (pGamePageItem == NULL) return false;
            }
        }
        catch (...) { return false; }

        //设置变量
        ZeroMemory(pGamePageItem, sizeof(CGamePageItem));
    }

    //设置数据
    pGamePageItem->m_bDisuse = false;
    CopyMemory(&pGamePageItem->m_GamePage, pGamePage, sizeof(tagGamePage));

    //设置索引
    m_PageItemMap[pGamePage->wPageID] = pGamePageItem;

    return true;
}

//插入房间
bool CServerListManager::InsertGameServer(tagGameServer * pGameServer)
{
    //效验参数
    ASSERT(pGameServer != NULL);
    if (pGameServer == NULL) return false;

    //查找房间
    WORD wKindID = 0;
    DWORD dwOnLineCount = 0L;
    DWORD dwMaxPlayer = 0L;
    CGameServerItem * pGameServerItem = NULL;

    //获取子项
    if (m_ServerItemMap.Lookup(pGameServer->wServerID, pGameServerItem) == FALSE)
    {
        //创建对象
        try
        {
            INT_PTR nStroeCount = m_ServerItemBuffer.GetCount();
            if (nStroeCount > 0)
            {
                pGameServerItem = m_ServerItemBuffer[nStroeCount - 1];
                m_ServerItemBuffer.RemoveAt(nStroeCount - 1);
            }
            else
            {
                pGameServerItem = new CGameServerItem;
                if (pGameServerItem == NULL) return false;
            }
        }
        catch (...) { return false; }

        //设置变量
        ZeroMemory(pGameServerItem, sizeof(CGameServerItem));
    }
    else
    {
        //保存变量
        wKindID = pGameServerItem->m_GameServer.wKindID;
        dwOnLineCount = pGameServerItem->m_GameServer.dwOnLineCount;
        dwMaxPlayer = pGameServerItem->m_GameServer.dwFullCount;
    }

    //设置数据
    pGameServerItem->m_bDisuse = false;
    CopyMemory(&pGameServerItem->m_GameServer, pGameServer, sizeof(tagGameServer));

    //设置人数
    if (wKindID != pGameServerItem->m_GameServer.wKindID)
    {
        //变量定义
        CGameKindItem * pGameKindItemLast = NULL;
        CGameKindItem * pGameKindItemCurrent = NULL;

        //历史人数
        if ((wKindID != 0) && (m_KindItemMap.Lookup(wKindID, pGameKindItemLast) == TRUE))
        {
            pGameKindItemLast->m_GameKind.dwOnLineCount -= dwOnLineCount;
            pGameKindItemLast->m_GameKind.dwFullCount -= dwMaxPlayer;
        }

        //当前人数
        if (m_KindItemMap.Lookup(pGameServer->wKindID, pGameKindItemCurrent) == TRUE)
        {
            pGameKindItemCurrent->m_GameKind.dwOnLineCount += pGameServer->dwOnLineCount;
            pGameKindItemCurrent->m_GameKind.dwFullCount += pGameServer->dwFullCount;
        }
    }
    else
    {
        //查找类型
        CGameKindItem * pGameKindItem = NULL;
        m_KindItemMap.Lookup(wKindID, pGameKindItem);

        //设置人数
        if (pGameKindItem != NULL)
        {
            pGameKindItem->m_GameKind.dwOnLineCount -= dwOnLineCount;
            pGameKindItem->m_GameKind.dwOnLineCount += pGameServer->dwOnLineCount;

            pGameKindItem->m_GameKind.dwFullCount -= dwMaxPlayer;
            pGameKindItem->m_GameKind.dwFullCount += pGameServer->dwFullCount;
        }
    }

    //设置索引
    m_ServerItemMap[pGameServer->wServerID] = pGameServerItem;

    return true;
}

//删除种类
bool CServerListManager::DeleteGameType(WORD wTypeID)
{
    //查找种类
    CGameTypeItem * pGameTypeItem = NULL;
    if (m_TypeItemMap.Lookup(wTypeID, pGameTypeItem) == FALSE) return false;

    //删除数据
    m_TypeItemMap.RemoveKey(wTypeID);
    m_TypeItemBuffer.Add(pGameTypeItem);

    return true;
}

//删除类型
bool CServerListManager::DeleteGameKind(WORD wKindID)
{
    //查找类型
    CGameKindItem * pGameKindItem = NULL;
    if (m_KindItemMap.Lookup(wKindID, pGameKindItem) == FALSE) return false;

    //删除数据
    m_KindItemMap.RemoveKey(wKindID);
    m_KindItemBuffer.Add(pGameKindItem);

    //设置变量
    ZeroMemory(pGameKindItem, sizeof(CGameKindItem));

    return true;
}

//删除节点
bool CServerListManager::DeleteGameNode(WORD wNodeID)
{
    //查找节点
    CGameNodeItem * pGameNodeItem = NULL;
    if (m_NodeItemMap.Lookup(wNodeID, pGameNodeItem) == FALSE) return false;

    //删除数据
    m_NodeItemMap.RemoveKey(wNodeID);
    m_NodeItemBuffer.Add(pGameNodeItem);

    //设置变量
    ZeroMemory(pGameNodeItem, sizeof(CGameNodeItem));

    return false;
}

//删除房间
bool CServerListManager::DeleteGameServer(WORD wServerID)
{
    //查找房间
    CGameServerItem * pGameServerItem = NULL;
    if (m_ServerItemMap.Lookup(wServerID, pGameServerItem) == FALSE) return false;

    //删除数据
    m_ServerItemMap.RemoveKey(wServerID);
    m_ServerItemBuffer.Add(pGameServerItem);

    //设置人数
    CGameKindItem * pGameKindItem = NULL;
    if (m_KindItemMap.Lookup(pGameServerItem->m_GameServer.wKindID, pGameKindItem) == TRUE)
    {
        tagGameServer * pGameServer = &pGameServerItem->m_GameServer;
        pGameKindItem->m_GameKind.dwOnLineCount -= pGameServer->dwOnLineCount;
        pGameKindItem->m_GameKind.dwFullCount -= pGameServer->dwFullCount;
    }

    return false;
}

//删除定制
bool CServerListManager::DeleteGamePage(WORD wPageID)
{
    //查找类型
    CGamePageItem * pGamePageItem = NULL;
    if (m_PageItemMap.Lookup(wPageID, pGamePageItem) == FALSE) return false;

    //删除数据
    m_PageItemMap.RemoveKey(wPageID);
    m_PageItemBuffer.Add(pGamePageItem);

    //设置变量
    ZeroMemory(pGamePageItem, sizeof(CGamePageItem));

    return true;
}

//枚举种类
CGameTypeItem * CServerListManager::EmunGameTypeItem(POSITION & Position)
{
    //变量定义
    WORD wKey = 0;
    CGameTypeItem * pGameTypeItem = NULL;

    //获取对象
    if (Position == NULL) Position = m_TypeItemMap.GetStartPosition();
    if (Position != NULL) m_TypeItemMap.GetNextAssoc(Position, wKey, pGameTypeItem);

    return pGameTypeItem;
}

//枚举类型
CGameKindItem * CServerListManager::EmunGameKindItem(POSITION & Position)
{
    //变量定义
    WORD wKey = 0;
    CGameKindItem * pGameKindItem = NULL;

    //获取对象
    if (Position == NULL) Position = m_KindItemMap.GetStartPosition();
    if (Position != NULL) m_KindItemMap.GetNextAssoc(Position, wKey, pGameKindItem);

    return pGameKindItem;
}

//枚举节点
CGameNodeItem * CServerListManager::EmunGameNodeItem(POSITION & Position)
{
    //变量定义
    WORD wKey = 0;
    CGameNodeItem * pGameNodeItem = NULL;

    //获取对象
    if (Position == NULL) Position = m_NodeItemMap.GetStartPosition();
    if (Position != NULL) m_NodeItemMap.GetNextAssoc(Position, wKey, pGameNodeItem);

    return pGameNodeItem;
}

//枚举房间
CGameServerItem * CServerListManager::EmunGameServerItem(POSITION & Position)
{
    //变量定义
    WORD wKey = 0;
    CGameServerItem * pGameServerItem = NULL;

    //获取对象
    if (Position == NULL) Position = m_ServerItemMap.GetStartPosition();
    if (Position != NULL) m_ServerItemMap.GetNextAssoc(Position, wKey, pGameServerItem);

    return pGameServerItem;
}

//枚举定制
CGamePageItem * CServerListManager::EmunGamePageItem(POSITION & Position)
{
    //变量定义
    WORD wKey = 0;
    CGamePageItem * pGamePageItem = NULL;

    //获取对象
    if (Position == NULL) Position = m_PageItemMap.GetStartPosition();
    if (Position != NULL) m_PageItemMap.GetNextAssoc(Position, wKey, pGamePageItem);

    return pGamePageItem;
}

//查找种类
CGameTypeItem * CServerListManager::SearchGameType(WORD wTypeID)
{
    CGameTypeItem * pGameTypeItem = NULL;
    m_TypeItemMap.Lookup(wTypeID, pGameTypeItem);
    return pGameTypeItem;
}

//查找类型
CGameKindItem * CServerListManager::SearchGameKind(WORD wKindID)
{
    CGameKindItem * pGameKindItem = NULL;
    m_KindItemMap.Lookup(wKindID, pGameKindItem);
    return pGameKindItem;
}

//查找节点
CGameNodeItem * CServerListManager::SearchGameNode(WORD wNodeID)
{
    CGameNodeItem * pGameNodeItem = NULL;
    m_NodeItemMap.Lookup(wNodeID, pGameNodeItem);
    return pGameNodeItem;
}

//推荐可用房间
tagGameServer * CServerListManager::SearchUseServer(WORD Level, WORD wServerID, bool filterGoldSvr/* = true 2017-11-20 不要推荐金币场服务器*/)
{
	CWHArray<tagGameServer*> List;

	CGameServerItem *pGameServerItem = NULL;
	POSITION Position = NULL;

	for (DWORD i = 0; i < GetGameServerCount(); i++)
	{
		//获取数据
		pGameServerItem = EmunGameServerItem(Position);
		if (pGameServerItem == NULL) break;

		///--过滤金币场
		if (filterGoldSvr && pGameServerItem->m_GameServer.wNodeID > 0)
		{
			continue;
		}

		if (pGameServerItem->m_GameServer.wServerID == wServerID)
		{
			continue;
		}

		if (pGameServerItem->m_GameServer.dwOnLineCount >= pGameServerItem->m_GameServer.dwFullCount)
		{
			if (wServerID != pGameServerItem->m_GameServer.wServerID) continue;
		}

		if (pGameServerItem->m_GameServer.wServerLevel > Level)
		{
			if (wServerID != pGameServerItem->m_GameServer.wServerID) continue;
		}

		if (pGameServerItem->m_GameServer.bService < 1)
		{
			if (pGameServerItem->m_GameServer.bService < 0 && pGameServerItem->m_GameServer.wServerLevel == 1 && Level < 2)
			{

			}
			else
			{
				continue;
			}
		}

		List.Add(&(pGameServerItem->m_GameServer));
	}

	//配需 求最优解
	int iCha = 0;
	tagGameServer * ptagGameServer = NULL;

	for (int i = 0; i < List.GetCount(); i++)
	{
		tagGameServer* pTemp = List[i];

		if (pTemp)
		{
			if ((pTemp->wTableFullCount - pTemp->wTableOnlineCount) > iCha)
			{
				iCha = pTemp->wTableFullCount - pTemp->wTableOnlineCount;
				ptagGameServer = pTemp;
			}
		}
	}

	List.RemoveAll();

	return ptagGameServer;
}

//查找房间
CGameServerItem * CServerListManager::SearchGameServer(WORD wServerID)
{
    CGameServerItem * pGameServerItem = NULL;
    m_ServerItemMap.Lookup(wServerID, pGameServerItem);
    return pGameServerItem;
}

//查找定制
CGamePageItem * CServerListManager::SearchGamePage(WORD wPageID)
{
    CGamePageItem * pGamePageItem = NULL;
    m_PageItemMap.Lookup(wPageID, pGamePageItem);
    return pGamePageItem;
}

//////////////////////////////////////////////////////////////////////////////////