zhujimajiang_redis/俱乐部/Source/ServerControl/GameService/AndroidUserItem.cpp

#include "StdAfx.h"
#include "AndroidUserItem.h"
#include "../../MessageDef/Pb_GameInfo.pb.h"
#include "../../GlobalDef/Util.h"
//////////////////////////////////////////////////////////////////////////////////

//静态变量
CTimerItemArray CAndroidUserItem::m_TimerItemBuffer;					//库存数组

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

//构造函数
CAndroidUserItem::CAndroidUserItem()
{
    //索引变量
    m_wRoundID = 1;
    m_wAndroidIndex = INVALID_WORD;

    //接口变量
    m_pIServerUserManager = NULL;
    m_pIAndroidUserManager = NULL;
    m_pIAndroidUserItemSink = NULL;

    //状态变量
    m_bWaitLeave = false;
    m_bStartClient = false;
    m_wAndroidAction = 0;
    m_dwPlayInnings = 0;
    m_cbGameStatus = GAME_STATUS_FREE;

    //用户状态
    m_CurrentUserStatus.cbUserStatus = US_NULL;
    m_CurrentUserStatus.wChairID = INVALID_CHAIR;
    m_CurrentUserStatus.wTableID = INVALID_TABLE;

    //绑定变量
    m_pIServerUserItem = NULL;

    //时间变量
    m_dwMinSitInterval = 0;
    m_dwMaxSitInterval = 0;
    m_dwStandupTickCount = 0;
    m_dwReposeTickCount = 0;

    //状态信息
    ZeroMemory(&m_AndroidService, sizeof(m_AndroidService));
    ZeroMemory(&m_AndroidItemConfig, sizeof(m_AndroidItemConfig));

    return;
}

//析构函数
CAndroidUserItem::~CAndroidUserItem()
{
    //删除时间
    KillGameTimer(0);

    //释放对象
    SafeRelease(m_pIAndroidUserItemSink);

    return;
}

//接口查询
VOID * CAndroidUserItem::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{
    QUERYINTERFACE(IAndroidUserItem, Guid, dwQueryVer);
    QUERYINTERFACE_IUNKNOWNEX(IAndroidUserItem, Guid, dwQueryVer);
    return NULL;
}

//获取 I D
DWORD CAndroidUserItem::GetUserID()
{
    return m_AndroidItemConfig.AndroidAccountsInfo.dwUserID;
}

//桌子号码
WORD CAndroidUserItem::GetTableID()
{
    //效验状态
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return INVALID_TABLE;

    return m_pIServerUserItem->GetTableID();
}

//椅子号码
WORD CAndroidUserItem::GetChairID()
{
    //效验状态
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return INVALID_CHAIR;

    return m_pIServerUserItem->GetChairID();
}


//获取自己
IServerUserItem * CAndroidUserItem::GetMeUserItem()
{
    return m_pIServerUserItem;
}

//游戏用户
IServerUserItem * CAndroidUserItem::GetTableUserItem(WORD wChariID)
{
    return NULL;
}

//发送函数
bool CAndroidUserItem::SendSocketData(WORD wSubCmdID)
{
    //状态效验
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return false;

    //发送数据
    DWORD dwAndroidID = MAKELONG(m_wAndroidIndex, m_wRoundID);
    m_pIAndroidUserManager->SendDataToServer(dwAndroidID, MDM_GF_GAME, wSubCmdID, NULL, 0);

    return true;
}

//存入游戏币
bool CAndroidUserItem::PerformSaveScore(SCORE lScore)
{
    //状态效验
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return false;

    //效验游戏币
    ASSERT(m_pIServerUserItem->GetUserScore() >= lScore);
    if (m_pIServerUserItem->GetUserScore() < lScore) return false;

    //修改游戏币
    m_pIServerUserItem->ModifyUserInsure(-lScore, 0L, 0L);

    return true;
}

//提取游戏币
bool CAndroidUserItem::PerformTakeScore(SCORE lScore)
{
    //状态效验
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return false;

    //修改游戏币
    m_pIServerUserItem->ModifyUserInsure(lScore, 0L, 0L);

    return true;
}

//发送函数
bool CAndroidUserItem::SendSocketData(WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
    //状态效验
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return false;

    //发送数据
    DWORD dwAndroidID = MAKELONG(m_wAndroidIndex, m_wRoundID);
    m_pIAndroidUserManager->SendDataToServer(dwAndroidID, MDM_GF_GAME, wSubCmdID, pData, wDataSize);

    return true;
}

//机器动作
bool CAndroidUserItem::JudgeAndroidActionAndRemove(WORD wAction)
{
    //变量定义
    bool bResult = (m_wAndroidAction&wAction) != 0;

    //移除动作
    if (bResult == true)
    {
        m_wAndroidAction &= ~wAction;

        //离开标识
        if (wAction == ANDROID_WAITLEAVE) m_bWaitLeave = true;
    }

    return bResult;
}

//删除时间
bool CAndroidUserItem::KillGameTimer(UINT nTimerID)
{
    //删除时间
    if (nTimerID != 0)
    {
        //寻找子项
        for (INT_PTR i = 0; i < m_TimerItemActive.GetCount(); i++)
        {
            //获取时间
            tagTimerItem * pTimerItem = m_TimerItemActive[i];

            //删除判断
            if (pTimerItem->nTimerID == nTimerID)
            {
                m_TimerItemActive.RemoveAt(i);
                m_TimerItemBuffer.Add(pTimerItem);

                return true;
            }
        }
    }
    else
    {
        m_TimerItemBuffer.Append(m_TimerItemActive);
        m_TimerItemActive.RemoveAll();
    }

    return false;
}

//设置时间
bool CAndroidUserItem::SetGameTimer(UINT nTimerID, UINT nElapse)
{
    //寻找子项
    for (INT_PTR i = 0; i < m_TimerItemActive.GetCount(); i++)
    {
        //获取时间
        tagTimerItem * pTimerItem = m_TimerItemActive[i];

        //设置判断
        if (pTimerItem->nTimerID == nTimerID)
        {
            pTimerItem->nTimeLeave = nElapse;
            return true;
        }
    }

    //变量定义
    tagTimerItem * pTimerItem = NULL;
    WORD wStorageCount = (WORD)m_TimerItemBuffer.GetCount();

    //库存子项
    if (wStorageCount > 0)
    {
        //获取对象
        pTimerItem = m_TimerItemBuffer[wStorageCount - 1];

        //加入数组
        m_TimerItemActive.Add(pTimerItem);
        m_TimerItemBuffer.RemoveAt(wStorageCount - 1);
    }

    //创建子项
    if (pTimerItem == NULL)
    {
        try
        {
            //创建对象
            pTimerItem = new tagTimerItem;
            if (pTimerItem == NULL) return false;

            //加入数组
            m_TimerItemActive.Add(pTimerItem);
        }
        catch (...)
        {
            ASSERT(FALSE);
            return false;
        }
    }

    //设置变量
    pTimerItem->nTimerID = nTimerID;
    pTimerItem->nTimeLeave = nElapse;

    return true;
}

//发送准备
bool CAndroidUserItem::SendUserReady(VOID * pData, WORD wDataSize)
{
    //状态效验
    //	ASSERT((m_pIServerUserItem!=NULL)&&(m_pIServerUserItem->GetUserStatus()==US_SIT));
    if ((m_pIServerUserItem == NULL) || (m_pIServerUserItem->GetUserStatus() != US_SIT)) return false;

    //发送准备
    DWORD dwAndroidID = MAKELONG(m_wAndroidIndex, m_wRoundID);
    m_pIAndroidUserManager->SendDataToServer(dwAndroidID, MDM_GF_FRAME, SUB_GF_USER_READY, pData, wDataSize);

    return true;
}

//发送聊天
bool CAndroidUserItem::SendChatMessage(DWORD dwTargetUserID, LPCTSTR pszChatString, COLORREF crColor)
{
    //效验用户
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return false;

    //构造信息
    CMD_GF_C_UserChat UserChat;
    lstrcpyn(UserChat.szChatString, pszChatString, CountArray(UserChat.szChatString));

    //构造数据
    UserChat.dwChatColor = crColor;
    UserChat.dwTargetUserID = dwTargetUserID;
    UserChat.wChatLength = CountStringBuffer(UserChat.szChatString);

    //发送命令
    DWORD dwAndroidID = MAKELONG(m_wAndroidIndex, m_wRoundID);
    WORD wSendSize = sizeof(UserChat)-sizeof(UserChat.szChatString) + UserChat.wChatLength*sizeof(TCHAR);

	GameInfo::PB_CS_UserChat Chat;
	Chat.set_dwchatcolor(UserChat.dwChatColor);
	Chat.set_wchatlength(UserChat.wChatLength);
	Chat.set_dwtargetuserid(UserChat.dwTargetUserID);
	std::string szChatString = CW2AEX<1024>(UserChat.szChatString, CP_UTF8).m_psz;
	Chat.set_szchatstring(szChatString);
	//发送数据
	std::string pbdata = Chat.SerializePartialAsString();
	//发送消息
    m_pIAndroidUserManager->SendDataToServer(dwAndroidID, MDM_GF_FRAME, SUB_GF_USER_CHAT, (void*)pbdata.c_str(), pbdata.length());

    return true;
}

//时间事件
bool CAndroidUserItem::OnTimerPulse(DWORD dwTimerID, WPARAM dwBindParameter)
{
    //寻找子项
    for (INT_PTR i = 0; i < m_TimerItemActive.GetCount();)
    {
        //变量定义
        tagTimerItem * pTimerItem = m_TimerItemActive[i];

        //时间处理
        if (pTimerItem->nTimeLeave <= 1L)
        {
            //设置数组
            m_TimerItemActive.RemoveAt(i);
            m_TimerItemBuffer.Add(pTimerItem);

            //时间通知
            if (m_pIAndroidUserItemSink != NULL)
            {
                m_pIAndroidUserItemSink->OnEventTimer(pTimerItem->nTimerID);
            }
        }
        else
        {
            //设置变量
            i++;
            pTimerItem->nTimeLeave--;
        }
    }


    return true;
}

//网络消息
bool CAndroidUserItem::OnSocketRead(WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
    //登录失败
    if ((wMainCmdID == MDM_GR_LOGON) && (wSubCmdID == SUB_GR_LOGON_FAILURE))
    {
        return OnSocketSubLogonFailure(pData, wDataSize);
    }

    //登录完成
    if ((wMainCmdID == MDM_GR_LOGON) && (wSubCmdID == SUB_GR_LOGON_FINISH))
    {
        return OnSocketSubLogonFinish(pData, wDataSize);
    }

    //用户状态
    if ((wMainCmdID == MDM_GR_USER) && (wSubCmdID == SUB_GR_USER_STATUS))
    {
        return OnSocketSubUserStatus(pData, wDataSize);
    }

    //游戏消息
    if ((wMainCmdID == MDM_GF_GAME) || (wMainCmdID == MDM_GF_FRAME))
    {
        return OnSocketGameMessage(wMainCmdID, wSubCmdID, pData, wDataSize);
    }

    //系统消息
    if ((wMainCmdID == MDM_CM_SYSTEM) && (wSubCmdID == SUB_CM_SYSTEM_MESSAGE))
    {
        return OnSocketSubSystemMessage(pData, wDataSize);
    }

    return true;
}

//游戏消息
bool CAndroidUserItem::OnSocketGameMessage(WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
    //游戏处理
    if ((wMainCmdID == MDM_GF_GAME) && (m_pIAndroidUserItemSink != NULL))
    {
        return m_pIAndroidUserItemSink->OnEventGameMessage(wSubCmdID, pData, wDataSize);
    }

    //框架处理
    if (wMainCmdID == MDM_GF_FRAME)
    {
        //默认处理
        switch (wSubCmdID)
        {
        case SUB_GF_GAME_STATUS:		//游戏状态
        {
			////效验参数
			//GameInfo::PB_CS_GameStatus GameStatus;
			//GameStatus.ParseFromArray(pData, wDataSize);
			////处理消息
			//CMD_GF_GameStatus pGameStatus;
			//ZeroMemory(&pGameStatus, sizeof(pGameStatus));
			//pGameStatus.cbGameStatus = GameStatus.cbgamestatus();
			//pGameStatus.cbAllowLookon = GameStatus.cballowlookon();
			//效验参数
			ASSERT(wDataSize == sizeof(CMD_GF_GameStatus));
			if (wDataSize != sizeof(CMD_GF_GameStatus)) return false;

			//消息处理
			CMD_GF_GameStatus* pGameStatus = (CMD_GF_GameStatus*)pData;
			//设置变量
			m_cbGameStatus = pGameStatus->cbGameStatus;

			return true;
        }
        case SUB_GF_GAME_SCENE:			//游戏场景
        {
                                            //游戏处理
                                            if (m_pIAndroidUserItemSink != NULL)
                                            {
                                                bool bLookonUser = (m_pIServerUserItem->GetUserStatus() == US_LOOKON);
                                                return m_pIAndroidUserItemSink->OnEventSceneMessage(m_cbGameStatus, bLookonUser, pData, wDataSize);
                                            }
                                            else
                                            {
                                                //发送开始
                                                IServerUserItem * pIServerUserItem = GetMeUserItem();
                                                if (pIServerUserItem->GetUserStatus() != US_READY) SendUserReady(NULL, 0);
                                            }

                                            return true;
        }
        case SUB_GF_USER_READY:			//用户准备
        {
                                            if (m_pIServerUserItem->GetUserStatus() >= US_READY)
                                                return true;

                                            //发送开始
                                            SendUserReady(NULL, 0);
                                            return true;
        }
        default:
        {
                   if (m_pIAndroidUserItemSink != NULL)
                       return m_pIAndroidUserItemSink->OnEventFrameMessage(wSubCmdID, pData, wDataSize);
                   break;
        }
        }
    }

    return true;
}

//登录失败
bool CAndroidUserItem::OnSocketSubLogonFailure(VOID * pData, WORD wDataSize)
{
    return true;
}

//登录完成
bool CAndroidUserItem::OnSocketSubLogonFinish(VOID * pData, WORD wDataSize)
{
    //设置变量
    m_cbGameStatus = GAME_STATUS_FREE;
    m_pIServerUserItem = m_pIServerUserManager->SearchUserItem(m_AndroidItemConfig.AndroidAccountsInfo.dwUserID);

    //状态效验
    ASSERT(m_pIServerUserItem != NULL);
    if (m_pIServerUserItem == NULL) return false;

    //用户状态
    m_CurrentUserStatus.wChairID = m_pIServerUserItem->GetChairID();
    m_CurrentUserStatus.wTableID = m_pIServerUserItem->GetTableID();
    m_CurrentUserStatus.cbUserStatus = m_pIServerUserItem->GetUserStatus();

    //规则变量
    CMD_GR_UserRule UserRule;
    ZeroMemory(&UserRule, sizeof(UserRule));

    //发送规则
    DWORD dwAndroidID = MAKELONG(m_wAndroidIndex, m_wRoundID);
    m_pIAndroidUserManager->SendDataToServer(dwAndroidID, MDM_GR_USER, SUB_GR_USER_RULE, &UserRule, sizeof(UserRule));

    //设置时间
    m_dwStandupTickCount = (DWORD)time(NULL);
    m_dwReposeTickCount = m_dwMinSitInterval + rand() % (__max(m_dwMaxSitInterval - m_dwMinSitInterval, 1));

    //重入判断
    if (m_pIServerUserItem->GetTableID() != INVALID_TABLE)
    {
        StartGameClient();
    }

    return true;
}

//用户状态
bool CAndroidUserItem::OnSocketSubUserStatus(VOID * pData, WORD wDataSize)
{
    //效验参数
    ASSERT(wDataSize == sizeof(CMD_GR_UserStatus));
    if (wDataSize < sizeof(CMD_GR_UserStatus)) return false;

    //变量定义
    CMD_GR_UserStatus * pUserStatus = (CMD_GR_UserStatus *)pData;

    //玩家判断
    if (pUserStatus->dwUserID != m_AndroidItemConfig.AndroidAccountsInfo.dwUserID)
    {
        return true;
    }

    //用户状态
    tagUserStatus LastUserStatus;
    CopyMemory(&LastUserStatus, &m_CurrentUserStatus, sizeof(LastUserStatus));
    CopyMemory(&m_CurrentUserStatus, &pUserStatus->UserStatus, sizeof(m_CurrentUserStatus));

    //开始切换
    if ((LastUserStatus.cbUserStatus != US_READY) && (m_CurrentUserStatus.cbUserStatus == US_READY))
    {
    }

    //机器起立
    if (m_CurrentUserStatus.cbUserStatus == US_FREE)
    {
        //设置局数
        m_dwPlayInnings = 0;
        m_wAndroidAction = 0;

        //设置时间
        m_dwStandupTickCount = (DWORD)time(NULL);
        m_dwReposeTickCount = m_dwMinSitInterval + rand() % (__max(m_dwMaxSitInterval - m_dwMinSitInterval, 1));
    }

    //游戏开始
    if (m_CurrentUserStatus.cbUserStatus == US_PLAYING)
    {
        m_dwPlayInnings++;
    }

    //坐下状态
    if (m_CurrentUserStatus.cbUserStatus == US_SIT)
    {
        if (m_AndroidService.dwSwitchTableInnings > 0 &&
            m_AndroidService.dwSwitchTableInnings <= m_dwPlayInnings)
        {
            //设置动作
            m_dwPlayInnings = 0;
            m_wAndroidAction |= ANDROID_WAITSTANDUP;
        }
    }

    //关闭判断
    if ((m_bStartClient == true) && (m_CurrentUserStatus.wTableID == INVALID_TABLE))
    {
        //关闭游戏
        CloseGameClient();

        return true;
    }

    //启动判断
    if ((m_bStartClient == false) && (m_CurrentUserStatus.wTableID != INVALID_TABLE))
    {
        //启动游戏
        StartGameClient();

        return true;
    }

    return true;
}

//系统消息
bool CAndroidUserItem::OnSocketSubSystemMessage(VOID * pData, WORD wDataSize)
{
    //变量定义
    CMD_CM_SystemMessage * pSystemMessage = (CMD_CM_SystemMessage *)pData;
    WORD wHeadSize = sizeof(CMD_CM_SystemMessage)-sizeof(pSystemMessage->szString);

    //效验参数
    ASSERT((wDataSize > wHeadSize) && (wDataSize == (wHeadSize + pSystemMessage->wLength*sizeof(TCHAR))));
    if ((wDataSize <= wHeadSize) || (wDataSize != (wHeadSize + pSystemMessage->wLength*sizeof(TCHAR)))) return false;

    //关闭处理
    //if ((pSystemMessage->wType&(SMT_CLOSE_ROOM | SMT_CLOSE_LINK)) != 0)
    //{
    //    //关闭处理
    //    DWORD dwAndroidID = MAKELONG(m_wAndroidIndex, m_wRoundID);
    //    m_pIAndroidUserManager->DeleteAndroidUserItem(dwAndroidID, true);
   // }

    return true;
}

//启动游戏
VOID CAndroidUserItem::StartGameClient()
{
    //状态判断
    ASSERT((m_bStartClient == false) && (m_pIServerUserItem != NULL));
    ASSERT((m_pIServerUserItem->GetTableID() != INVALID_TABLE) && (m_pIServerUserItem->GetChairID() != INVALID_CHAIR));

    //设置变量
    m_bStartClient = true;

    //变量定义
    CMD_GF_GameOption GameOption;
    ZeroMemory(&GameOption, sizeof(GameOption));

    //构造数据
    GameOption.cbAllowLookon = FALSE;
    GameOption.dwFrameVersion = INVALID_DWORD;
    GameOption.dwClientVersion = INVALID_DWORD;

    //发送数据
    DWORD dwAndroidID = MAKELONG(m_wAndroidIndex, m_wRoundID);
    m_pIAndroidUserManager->SendDataToServer(dwAndroidID, MDM_GF_FRAME, SUB_GF_GAME_OPTION, &GameOption, sizeof(GameOption));

    return;
}

//关闭游戏
VOID CAndroidUserItem::CloseGameClient()
{
    //状态判断
    ASSERT((m_bStartClient == true) && (m_pIServerUserItem != NULL));
    ASSERT((m_pIServerUserItem->GetTableID() == INVALID_TABLE) && (m_pIServerUserItem->GetChairID() == INVALID_CHAIR));

    //删除时间
    KillGameTimer(0);

    //设置变量
    m_bStartClient = false;
    m_cbGameStatus = GAME_STATUS_FREE;

    //游戏复位
    if (m_pIAndroidUserItemSink != NULL)
    {
        m_pIAndroidUserItemSink->RepositionSink();
    }

    return;
}

//复位数据
VOID CAndroidUserItem::RepositUserItem()
{
    //状态变量
    m_bWaitLeave = false;
    m_bStartClient = false;
    m_wAndroidAction = 0;
    m_dwPlayInnings = 0;
    m_cbGameStatus = GAME_STATUS_FREE;

    //用户状态
    m_CurrentUserStatus.cbUserStatus = US_NULL;
    m_CurrentUserStatus.wChairID = INVALID_CHAIR;
    m_CurrentUserStatus.wTableID = INVALID_TABLE;

    //绑定变量
    m_pIServerUserItem = NULL;

    //时间变量
    m_dwMinSitInterval = 0;
    m_dwMaxSitInterval = 0;
    m_dwStandupTickCount = 0;
    m_dwReposeTickCount = 0;

    //状态信息
    ZeroMemory(&m_AndroidService, sizeof(m_AndroidService));
    ZeroMemory(&m_AndroidItemConfig, sizeof(m_AndroidItemConfig));

    //删除时间
    m_TimerItemBuffer.Append(m_TimerItemActive);
    m_TimerItemActive.RemoveAll();

    //索引变量
    m_wRoundID = __max(1, m_wRoundID + 1);

    //复位游戏
    if (m_pIAndroidUserItemSink != NULL)
    {
        m_pIAndroidUserItemSink->RepositionSink();
    }

    return;
}

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