lua短连接

--[[
封装Socket短连，不在绑定view
]]


local targetPlatform = cc.Application:getInstance():getTargetPlatform()


local ExternalFun = appdf.req(appdf.EXTERNAL_SRC .. "ExternalFun")


local cmd_private = appdf.req(PriRoom.MODULE.PRIHEADER .. "CMD_Private")
local define_private = appdf.req(PriRoom.MODULE.PRIHEADER .. "Define_Private")
local struct_private = appdf.req(PriRoom.MODULE.PRIHEADER .. "Struct_Private")
local logincmd = appdf.req(appdf.HEADER_SRC .. "CMD_LogonServer")


-- 登陆服务器CMD
local cmd_pri_login = cmd_private.login
-- 游戏服务器CMD
local cmd_pri_game = cmd_private.game


local NetEvent = class("NetEvent")


function NetEvent:ctor(name,...)


print("NetEvent create:",name,...)





self._threadid  = nil
self._socket    = nil


self.m_tabCacheMsg = {}


self._callbackCount = 1 -- 返回消息数量，默认为1


return self:setEvent(name,...)
end


function NetEvent:setEvent(name,...)


self.eventName_ = name
self.params_ = {...}


print("NetEvent:setEvent",name,self.eventName_)
end


function NetEvent:setAddress(szUrl,nPort)
self._szServerUrl = szUrl
self._nServerPort = nPort
end


--网络错误
function NetEvent:onSocketError(pData)
if self._threadid == nil then
return
end
local cachemsg = cjson.encode(self.m_tabCacheMsg)
if nil ~= cachemsg then
if cc.PLATFORM_OS_WINDOWS == targetPlatform then
LogAsset:getInstance():logData(cachemsg or "",true)
else
buglyReportLuaException(cachemsg or "", debug.traceback())
end
end

self:onCloseSocket()


if not pData then
self:onErrorCallback("网络断开！")
elseif type(pData) == "string" then
self:onErrorCallback(pData)
else
local errorcode = pData:readword()
if errorcode == nil then
self:onErrorCallback("网络断开！")
elseif errorcode == 6 then
self:onErrorCallback("长时间无响应，网络断开！")
elseif errorcode == 3 then
self:onErrorCallback("网络连接超时, 请重试!")
-- 切换地址
if nil ~= yl.SERVER_LIST[yl.CURRENT_INDEX] then
yl.LOGONSERVER = yl.SERVER_LIST[yl.CURRENT_INDEX]
end
yl.CURRENT_INDEX = yl.CURRENT_INDEX + 1
if yl.CURRENT_INDEX > yl.TOTAL_COUNT then
yl.CURRENT_INDEX = 1
end
else
print("网络错误，code：",errorcode)
self:onErrorCallback("网络异常")
end
end


end


--启动网络
function  NetEvent:start()


print("NetEvent:start ... ")


--已存在连接
if self._socket ~= nil then
return self:onErrorCallback("此NetEvent已经启动过了")
end
--创建连接
local this = self


self._szServerUrl = self._szServerUrl or yl.LOGONSERVER
self._nServerPort = self._nServerPort or yl.LOGONPORT


print("NetEvent:start host",self._szServerUrl)
print("NetEvent:start port",self._nServerPort)


self._SocketFun = function(pData)
this:onSocketCallBack(pData)
end
self._socket = CClientSocket:createSocket(self._SocketFun)
self._socket:setwaittime(0)
self._sctime = os.time()
if self._socket:connectSocket(self._szServerUrl,self._nServerPort,yl.VALIDATE) == true then
self._threadid = 0
return true
else --创建失败
self:onCloseSocket() 
return self:onErrorCallback("创建Socket失败")
end
end


--网络消息回调
function NetEvent:onSocketCallBack(pData)
--无效数据
if  pData == nil then 
print("NetEvent onSocketCallBack pData == nil")
return
end

-- 连接命令
local main = pData:getmain()
local sub =pData:getsub()
print("NetEvent onSocketCallBack main:"..main.."#sub:"..sub)
if main == yl.MAIN_SOCKET_INFO then --网络状态
if sub == yl.SUB_SOCKET_CONNECT then
self._threadid = 1
print("NetEvent connect use time:",os.time() - self._sctime)
self:onConnected()
elseif sub == yl.SUB_SOCKET_ERROR then --网络错误
if self._threadid then
self:onSocketError(pData)
else
self:onCloseSocket()
end
else
self:onCloseSocket()
end
else
if 1 == self._threadid then--网络数据
self:onSocketEvent(main,sub,pData)
end
end
end


--关闭网络
function NetEvent:onCloseSocket()
if self._socket then
self._socket:relaseSocket()
self._socket = nil
end
if self._threadid then
self._threadid = nil
end
self._SocketFun = nil
end


--发送数据
function NetEvent:sendSocketData(pData)
if self._socket == nil then
self:onErrorCallback("发送数据失败，此Socket已经关闭")
return false
end
local tabCache = {}
tabCache["main"] = pData:getmain()
tabCache["sub"] = pData:getsub()
tabCache["len"] = pData:getlen()
tabCache["kindid"] = GlobalUserItem.nCurGameKind
table.insert( self.m_tabCacheMsg, tabCache )
if #self.m_tabCacheMsg > 5 then
table.remove(self.m_tabCacheMsg, 1)
end  
if not self._socket:sendData(pData) then
self:onSocketError("发送数据失败！")
return false
end
return true
end


--网络信息(短连接)
function NetEvent:onSocketEvent(main,sub,pData)

self._callbackCount = self._callbackCount - 1
if self._callbackCount <= 0 then
self:onCloseSocket()
end


self._tag = main .. "#" .. sub
print(self._tag)
-- 房卡模式的主命令
if main == cmd_pri_login.MDM_MB_PERSONAL_SERVICE then
if sub == cmd_pri_login.SUB_GR_USER_QUERY_ROOM_SCORE_RESULT then -- 参与的房间列表
return self:onSubJoinRoomList(pData)
elseif sub == cmd_pri_login.SUB_MB_QUERY_PERSONAL_ROOM_LIST_RESULT then -- 创建的房间列表
return self:onSubPrivateRoomList(pData)
-- elseif sub == cmd_pri_login.SUB_MB_PERSONAL_PARAMETER then -- 获取房间配置
-- return self:onQueryRoomParam(pData)
elseif sub == cmd_pri_login.SUB_MB_PERSONAL_PARAMETER then
return self:OnGetPriRoomProperty(pData)
elseif sub == cmd_pri_login.SUB_MB_PERSONAL_FEE_PARAMETER then
return self:OnGetPriRoomFee(pData)
elseif sub == cmd_pri_login.SUB_MB_QUERY_GAME_SERVER_RESULT then
return self:onSubGameServerResult(pData)
elseif sub == cmd_pri_login.SUB_MB_DISSUME_SEARCH_RESULT then -- 解散房间
return self:onSubDissumeSearchReasult(pData)
elseif sub == cmd_pri_login.SUB_MB_SEARCH_RESULT then                   -- 房间搜索结果
return self:onSubSearchRoomResult(pData)
elseif sub == cmd_pri_login.SUB_MB_QUERY_SHARE_RECORD then --推广奖励记录
return self:onSubShareRecode(pData)
elseif sub == cmd_pri_login.SUB_MB_QUERY_PERSONAL_ROOM_USER_INFO then --私人房请求玩家的房卡和游戏豆
return self:onSubQueryUserRoomCardBeans(pData)
end


elseif main == yl.MDM_GP_USER_SERVICE then
if sub == yl.SUB_GP_GAME_RECORD_LIST then -- 获取所有游戏的战绩列表
return self:onGetGameRecordList(pData)
elseif sub == yl.SUB_GP_GAME_RECORD_TOTAL then -- 获取指令recordid的战绩
return self:onGetGameRecord(pData)
elseif sub == yl.SUB_GP_GAME_RECORD_CHILD_ID then -- 获取指令详细的战绩
return self:onGetGameChildRecord(pData)
elseif sub == yl.SUB_GP_OPERATE_FAILURE then -- 获取指令详细的战绩
return self:onOperateFailure(pData)
end
end

return self:onErrorCallback("NetEvent 未注册的返回指令:" .. main .. "#" .. sub)
end
--连接OK
function NetEvent:onConnected()


print("NetEvent:onConnected",self.eventName_, self.eventName_ and self.params_)


if self.eventName_ and self.params_ then
local func = self[self.eventName_]
if type(func) == "function" then
return func(self,unpack(self.params_))
end
assert(false,"NetEvent eventName error, can not find function of:" .. self.eventName_)
end
end


function NetEvent:onOperateFailure(pData)
local lResultCode = pData:readint()
local szDescribe = pData:readstring()
self:onErrorCallback(szDescribe)
return self:onCloseSocket()
end


function NetEvent:onErrorCallback(errmsg)
print("onErrorCallback:",errmsg)
end


function NetEvent:onDataCallback(data,tag)
print("onDataCallback:",data,tag)
end


--=============================================================================================================
--=============================================================================================================
--=============================================================================================================
--=============================================================================================================


function NetEvent:getMyReword( list )
    if type(list) ~= "table" then
        return 0
    end
    for k,v in pairs(list) do
        if v["dwUserID"] == GlobalUserItem.dwUserID then
            return (tonumber(v.lScore) or 0)
        end
    end
    return 0
end


function NetEvent:sendQueryShareRecoder()
print("NetEvent sendQueryShareRecoder:")


local buffer = ExternalFun.create_netdata(cmd_pri_login.CMD_GP_QueryShareRecoder)
    buffer:setcmdinfo(cmd_pri_login.MDM_MB_PERSONAL_SERVICE,cmd_pri_login.SUB_MB_QUERY_SHARE_RECORD)
    buffer:pushdword(GlobalUserItem.dwUserID)
    if not self:sendSocketData(buffer) then
        self:onErrorCallback("发送查询参与列表失败！",self._tag)
    end
end


function NetEvent:onSubShareRecode(pData)
local ta={}
local allLen = pData :getlen()
    local curLen = pData:getcurlen()
if 0 == allLen then
return self:onDataCallback(ta)
end

while(curLen < allLen)
do
ta[#ta +1] = ExternalFun.read_netdata(cmd_pri_login.CMD_GP_ShareRecoder,pData)
curLen =pData:getcurlen()
end


    return  self:onDataCallback(ta)
end


function NetEvent:onSubQueryUserRoomCardBeans(pData)
print("私人房请求玩家房卡和游戏豆")
local buffer = ExternalFun.create_netdata(cmd_pri_login.DBO_MB_PersonalRoomUserInfo)
dump(buffer)
end


-- 发送查询参与列表
function NetEvent:sendQueryJoinRoomList(gameKindID)
    local buffer = ExternalFun.create_netdata(cmd_pri_login.CMD_MB_QeuryPersonalRoomList)
    buffer:setcmdinfo(cmd_pri_login.MDM_MB_PERSONAL_SERVICE,cmd_pri_login.SUB_GR_USER_QUERY_ROOM_SCORE)
    buffer:pushdword(GlobalUserItem.dwUserID)
    buffer:pushdword(tonumber(gameKindID) or GlobalUserItem.nCurGameKind)
    if not self:sendSocketData(buffer) then
        self:onErrorCallback("发送查询参与列表失败！",self._tag)
    end
end
-- 返回参与列表
function NetEvent:onSubJoinRoomList( pData )
local m_tabJoinRecord = {}
    -- 计算数目
    local len = pData:getlen()
    local itemcount = math.floor(len/define_private.LEN_PERSONAL_ROOM_SCORE)
    -- print("NetEvent onSubJoinRoomList " .. itemcount)
    for i = 1, itemcount do
        local pServer = ExternalFun.read_netdata(struct_private.tagQueryPersonalRoomUserScore, pData)
        pServer.lScore = self:getMyReword(pServer["PersonalUserScoreInfo"][1])
        -- 时间戳
        local tt = pServer.sysDissumeTime
        pServer.sortTimeStmp = os.time({day=tt.wDay, month=tt.wMonth, year=tt.wYear, hour=tt.wHour, min=tt.wMinute, sec=tt.wSecond}) or 0
        pServer.bFlagOnGame = (pServer.sortTimeStmp == 0)
        pServer.nOnGameOrder = pServer.bFlagOnGame and 1 or 0
        tt = pServer.sysCreateTime
        pServer.sortCreateTimeStmp = os.time({day=tt.wDay, month=tt.wMonth, year=tt.wYear, hour=tt.wHour, min=tt.wMinute, sec=tt.wSecond}) or 0
        table.insert(m_tabJoinRecord, pServer)        
    end
    table.sort( m_tabJoinRecord, function(a, b)
        if a.bFlagOnGame ~= b.bFlagOnGame then
            if a.nOnGameOrder == b.nOnGameOrder then
                return a.sortCreateTimeStmp < b.sortCreateTimeStmp
            else
                return a.nOnGameOrder < b.nOnGameOrder
            end
        else
            return a.sortTimeStmp < b.sortTimeStmp
        end
    end )
    return  self:onDataCallback(m_tabJoinRecord,self._tag)
end


-- 发送查询私人房列表
function NetEvent:sendQueryRoomList(gameKindID)
print("NetEvent sendQueryRoomList:",gameKindID)
    local buffer = ExternalFun.create_netdata(cmd_pri_login.CMD_MB_QeuryPersonalRoomList)
    buffer:setcmdinfo(cmd_pri_login.MDM_MB_PERSONAL_SERVICE,cmd_pri_login.SUB_MB_QUERY_PERSONAL_ROOM_LIST)
    buffer:pushdword(GlobalUserItem.dwUserID)
    buffer:pushdword(tonumber(gameKindID) or GlobalUserItem.nCurGameKind)
    if not self:sendSocketData(buffer) and nil ~= self._callBack then
        self:onErrorCallback("发送查询房间列表失败！",self._tag)
    end
end
-- 返回私人房列表
function NetEvent:onSubPrivateRoomList( pData )
print("NetEvent onSubPrivateRoomList")
    local m_tabCreateRecord = {}


    local cmd_table = ExternalFun.read_netdata(cmd_pri_login.CMD_MB_PersonalRoomInfoList, pData)


    local listinfo = cmd_table.PersonalRoomInfo[1]


    for i = 1, define_private.MAX_CREATE_PERSONAL_ROOM do
        local info = listinfo[i]
        if info.szRoomID ~= "" then


        -- dump(info.PersonalUserScoreInfo)


            info.lScore = info.lTaxCount--self:getMyReword(info.PersonalUserScoreInfo[1])
            -- 时间戳
            local tt = info.sysDissumeTime
            info.sortTimeStmp = os.time({day=tt.wDay, month=tt.wMonth, year=tt.wYear, hour=tt.wHour, min=tt.wMinute, sec=tt.wSecond})
            tt = info.sysCreateTime
            info.createTimeStmp = os.time({day=tt.wDay, month=tt.wMonth, year=tt.wYear, hour=tt.wHour, min=tt.wMinute, sec=tt.wSecond})
            table.insert(m_tabCreateRecord, info)
        else
            break
        end
    end
    table.sort( m_tabCreateRecord, function(a, b)
        if a.cbIsDisssumRoom ~= b.cbIsDisssumRoom then
            return a.cbIsDisssumRoom > b.cbIsDisssumRoom
        elseif a.cbIsDisssumRoom == 0 and a.cbIsDisssumRoom == b.cbIsDisssumRoom then
            return a.createTimeStmp < b.createTimeStmp
        else
            return a.sortTimeStmp < b.sortTimeStmp
        end        
    end )
    return self:onDataCallback(m_tabCreateRecord,self._tag)
end


-- 发送请求配置
function NetEvent:sendQueryRoomParam(gameKindID)


self._callbackCount = 2


    local buffer = ExternalFun.create_netdata(cmd_pri_login.CMD_MB_GetPersonalParameter)
    buffer:setcmdinfo(cmd_pri_login.MDM_MB_PERSONAL_SERVICE,cmd_pri_login.SUB_MB_GET_PERSONAL_PARAMETER)
    buffer:pushdword(tonumber(gameKindID) or GlobalUserItem.nCurGameKind)
    if not self:sendSocketData(buffer) then
        self:onErrorCallback("发送请求配置失败！",self._tag)
    end
end


--取得私人房属性
function NetEvent:OnGetPriRoomProperty(pData)
local tempProperty = ExternalFun.read_netdata( struct_private.tagPersonalRoomOption, pData )
print("取得私人房属性：")
-- dump(tempProperty)
self._property = tempProperty
end
--取得私人房费用配置
function NetEvent:OnGetPriRoomFee(pData)

local feeConfingList={}
    local len = pData:getlen()
    local count = math.floor(len/define_private.LEN_PERSONAL_TABLE_PARAMETER)
    for idx = 1, count do
        local param = ExternalFun.read_netdata( struct_private.tagPersonalTableParameter, pData )
        table.insert(feeConfingList, param)
    end
    table.sort( feeConfingList, function(a, b)
        return a.dwDrawCountLimit < b.dwDrawCountLimit
    end )
print("取得私人房间费用配置")


local data = {}
data.property = self._property
data.freeConfingList = feeConfingList
return self:onDataCallback(data,self._tag)
end


-- 发送查询私人房
function NetEvent:sendSearchRoom(roomId,nCurGameKind)
    local buffer = ExternalFun.create_netdata(cmd_pri_login.CMD_MB_SerchServerTableEnter)
    buffer:setcmdinfo(cmd_pri_login.MDM_MB_PERSONAL_SERVICE,cmd_pri_login.SUB_MB_SEARCH_SERVER_TABLE)
    buffer:pushstring(roomId or 0, define_private.ROOM_ID_LEN)
    buffer:pushdword(nCurGameKind or GlobalUserItem.nCurGameKind)
    if not self:sendSocketData(buffer) then
        self:onErrorCallback("发送查询房间失败！")
    end
end
function NetEvent:onSubSearchRoomResult(pData)
local cmd_table = ExternalFun.read_netdata(cmd_pri_login.CMD_MB_SearchResult, pData)
    dump(cmd_table, "CMD_MB_SearchResult", 6)
    -- 0 == cmd_table.dwServerID
    return self:onDataCallback(cmd_table, self._tag)
end


--[[
-- 用户ID
    {t = "dword", k = "dwUserID"},
    -- 类型ID
    {t = "dword", k = "dwKindID"},
    -- 是否参与 (0 不参与; 1 参与)
    {t = "byte", k = "cbIsJoinGame"},
    {t = "byte", k = "cbPlayCostMode"}, -- 0 房主 2 AA
]]
-- 发送创建房间
function NetEvent:sendCreateRoom(gameKindID,pData,cbIsJoinGame,cbPlayCostMode)
local buffer = ExternalFun.create_netdata(cmd_pri_login.CMD_MB_QueryGameServer)
    buffer:setcmdinfo(cmd_pri_login.MDM_MB_PERSONAL_SERVICE,cmd_pri_login.SUB_MB_QUERY_GAME_SERVER)
    buffer:pushdword(GlobalUserItem.dwUserID)
    buffer:pushdword(tonumber(gameKindID) or GlobalUserItem.nCurGameKind)
    buffer:pushbyte(cbIsJoinGame or 0)
    local cbPlayCostMode = tonumber(cbPlayCostMode) or 0
    buffer:pushbyte(cbPlayCostMode ~= 0 and 2 or 0)
self._pData=pData
local leng = pData:getlen()
    if not self:sendSocketData(buffer) then
        self:onErrorCallback("发送创建房间失败！")
    end
end
-- -- 创建结果
function NetEvent:onSubGameServerResult( pData )
print("创建回调")
    local cmd_table = ExternalFun.read_netdata( cmd_pri_login.CMD_MB_QueryGameServerResult, pData )
    dump(cmd_table, "CMD_MB_QueryGameServerResult", 6)
    local tips = cmd_table.szErrDescrybe


    if false == cmd_table.bCanCreateRoom then
        if type(tips) == "string" then
            self:onErrorCallback(tips)
        end
        return true
    end
    if 0 == cmd_table.dwServerID and true == cmd_table.bCanCreateRoom then
        if type(tips) == "string" then
            self:onErrorCallback(tips)
        end
        return true
    end    


    self._loginEvent = "createRoom"


    -- 发送登陆
    self:LoginPrivRoom(cmd_table.dwServerID)
    return false
end
--------------------------------------------------------------------------------
--这里做个测试创建房间PriRoom:getInstance():
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
function NetEvent:LoginPrivRoom(dwServerID)
local ev = {}
NetEvent._gameList = NetEvent._gameList or PriRoom:getInstance()._scene:getApp()._gameList
for _,v in ipairs(GlobalUserItem.priRoomlist) do
-- dump(v)
if v.wServerID == dwServerID then
local kindID = tostring(v.wKindID)
self.temproomInfo = v
ev.host =v.szServerAddr
ev.port = v.wServerPort
for _,gameInfo in ipairs(NetEvent._gameList) do
if gameInfo._KindID == kindID then
dump(gameInfo)
ev._kindVersion = gameInfo._KindVersion
ev._wKindID = gameInfo._KindID
break
end
end
break
end
end
-- dump(ev)
if ev._kindVersion==nil or ev._wKindID==nil then
return self:onErrorCallback("游戏未配置")
end



ev._parent = self

--创建socket回调
function ev:socketCallback(pData)
local main = pData:getmain()
local sub =pData:getsub()
print("消息=========>main:"..main.." sub:"..sub)
if main == yl.MAIN_SOCKET_INFO then --main:0 网络状态
if sub == yl.SUB_SOCKET_CONNECT then --sub:1
return self:onConnected()
elseif sub == yl.SUB_SOCKET_ERROR then --网络错误
self._socket:relaseSocket()
self._socket = nil
return self._parent:onErrorCallback("创建链接Socket失败")
end
elseif main == yl.MDM_GR_LOGON then
return self:onSocketEvent(sub,pData)
elseif main == yl.MDM_GR_STATUS then -- 4 状态消息
return self:onSocketStatusEvent(sub,pData)
elseif main == cmd_private.game.MDM_GR_PERSONAL_TABLE then --210


if sub == cmd_private.game.SUB_GR_CREATE_SUCCESS then
return self:onSocketCreateRoomSuccess(pData)
elseif sub == cmd_private.game.SUB_GR_CURRECE_ROOMCARD_AND_BEAN then -- 强制解散桌子后的游戏豆和房卡数量
return self:onSubCancelTableScoreInfo( pData )
elseif sub == cmd_private.game.SUB_GR_CANCEL_TABLE_RESULT then -- 强制解散桌子结果
return self:onSubCancelTableResult( pData )
elseif sub == cmd_private.game.SUB_GR_CREATE_FAILURE then
return self:onSocketCreateRoomFail(pData)
end
end
print("未处理消息!!! main:",main," sub:",sub)
end
--链接
function ev:connect()
self._sctime = os.time()
self._socket = CClientSocket:createSocket(handler(self,self.socketCallback))
self._socket:setwaittime(0)


if not self._socket:connectSocket(self.host,self.port,yl.VALIDATE) then
return self._parent:onErrorCallback("创建链接Socket失败")
end
end
--链接成功后登陆
function ev:onConnected()
print("链接成功!")
print("开始发送登录...")


print("NetEvent sub ev connect use time:",os.time() - self._sctime)
self._sctime = os.time()


local dataBuffer = CCmd_Data:create(213)
--初始化参数 这里没有初始化参数
--self:onInitData()
dataBuffer:setcmdinfo(yl.MDM_GR_LOGON, yl.SUB_GR_LOGON_MOBILE)
dataBuffer:pushword(self._wKindID)
dataBuffer:pushdword(self._kindVersion)
print("KindId:",self._wKindID," ,KindVersion:" ,self._kindVersion)
dataBuffer:pushbyte(yl.DEVICE_TYPE)
dataBuffer:pushword(0x0011)
dataBuffer:pushword(255)


dataBuffer:pushdword(GlobalUserItem.dwUserID)
dataBuffer:pushstring(GlobalUserItem.szDynamicPass,33)
dataBuffer:pushstring(GlobalUserItem.szRoomPasswd,33)
dataBuffer:pushstring(GlobalUserItem.szMachine,33)


if not self._socket:sendData(dataBuffer) then
self._parent:onErrorCallback("发送数据失败！")
self._socket:relaseSocket()
self._socket = nil
return false
end
end
--登陆事件
function ev:onSocketEvent(sub,pData)
if sub == yl.SUB_GR_LOGON_FINISH then  --登陆完成
print("登陆完成:",event)
print("NetEvent sub ev logon use time:",os.time() - self._sctime)


local event = self._parent._loginEvent


if event == "createRoom" then -- 创建房间
self:sendCreateRoom()
elseif event == "dissumeRoom" then -- 解散房间
self:sendDissumeGame()
end
elseif sub == yl.SUB_MB_LOGON_FAILURE then --登陆失败
print("=========== 登录失败 ===========")
local cmd_table = ExternalFun.read_netdata(logincmd.CMD_MB_LogonFailure, pData)
if 10 == cmd_table.lResultCode then
GlobalUserItem.setBindingAccount()
end
self._socket:relaseSocket()
self._socket = nil
self._parent:onErrorCallback(cmd_table.szDescribeString,self._parent._tag)
end
end
--创建房间
function ev:sendCreateRoom()
if not self._socket:sendData(self._parent._pData) then
self._parent:onErrorCallback("发送数据失败！")
self._socket:relaseSocket()
self._socket = nil
return false
end
-- self._parent._pData:release()
end
--解散房间
function ev:sendDissumeGame()
   local buffer = ExternalFun.create_netdata(cmd_pri_game.CMD_GR_HostDissumeGame)
        buffer:setcmdinfo(cmd_pri_game.MDM_GR_PERSONAL_TABLE,cmd_pri_game.SUB_GR_HOSTL_DISSUME_TABLE)
        buffer:pushdword(GlobalUserItem.dwUserID)
        buffer:pushdword(self._parent._dwTableID or 0)
        if not self._socket:sendData(buffer) then
            self._parent:onErrorCallback("发送解散游戏失败！")
            self._socket:relaseSocket()
self._socket = nil
        end
end
--创建事件
function ev:onSocketCreateRoomSuccess(pData)
print("创建房间成功")
local cmd_table = ExternalFun.read_netdata(cmd_private.game.CMD_GR_CreateSuccess, pData)
-- dump(cmd_table)


self._socket:relaseSocket()
self._socket = nil


return self._parent:onDataCallback(cmd_table,self._parent._tag,pData)
end
--创建失败
function ev:onSocketCreateRoomFail(pData)
local cmd_table = ExternalFun.read_netdata(cmd_pri_game.CMD_GR_CreateFailure, pData)
self._socket:relaseSocket()
self._socket = nil
self._parent:onErrorCallback(cmd_table.szDescribeString,self._parent._tag)
end
-- 解散后财富信息
function ev:onSubCancelTableScoreInfo( pData )
   local cmd_table = ExternalFun.read_netdata(cmd_pri_game.CMD_GR_CurrenceRoomCardAndBeans, pData)
   -- 个人财富
   GlobalUserItem.dUserBeans = cmd_table.dbBeans
   GlobalUserItem.lRoomCard = cmd_table.lRoomCard
   -- 通知更新        
   local eventListener = cc.EventCustom:new(yl.RY_USERINFO_NOTIFY)
   eventListener.obj = yl.RY_MSG_USERWEALTH
   cc.Director:getInstance():getEventDispatcher():dispatchEvent(eventListener)
end
-- 私人房解散结果
function ev:onSubCancelTableResult( pData )
   local cmd_table = ExternalFun.read_netdata(cmd_pri_game.CMD_GR_DissumeTable, pData)


   self._socket:relaseSocket()
self._socket = nil


return self._parent:onDataCallback(cmd_table,self._tag,pData)
end
--状态事件
function ev:onSocketStatusEvent(sub,pData)
end
ev:connect()
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


-- 解析战绩列表
function NetEvent:decodePrivateRandTotalRecordList(pData)
local recordList = {}


local dwUserID = pData:readdword()
local streamLen = pData:readint()


-- print("decodePrivateRandTotalRecordList dwUserID:",dwUserID)
-- print("decodePrivateRandTotalRecordList streamLen:",streamLen)


recordList.dwUserID = dwUserID
recordList.privateRandTotalRecord = {}


for i=1,streamLen do
recordList.privateRandTotalRecord[i] = self:decodePrivateRandTotalRecord(pData)
end
return recordList
end
-- 解析单局战绩
function NetEvent:decodePrivateRandTotalRecord(pData)
local info = {}


info.iRoomNum = pData:readint()


local kUserIDLen = pData:readint()


-- print("decodePrivateRandTotalRecord iRoomNum:",info.iRoomNum)
-- print("decodePrivateRandTotalRecord kUserIDLen:",kUserIDLen)


info.kUserIDs = {}
for i=1,kUserIDLen do
info.kUserIDs[i] = pData:readint()
end


info.kNickNames = {}
local kNickNameLen = pData:readint()
-- print(" kNickNameLen ",kNickNameLen)
for i=1,kNickNameLen do
local strlen = pData:readint()
local str = ""
for j=1,strlen do
str = str .. string.char(pData:readbyte())
end
info.kNickNames[i] = str
end


info.kScores = {}
local kScoreLen = pData:readint()
for i=1,kScoreLen do
info.kScores[i] = pData:readint()
end


info.kPlayTime = {}
info.kPlayTime.wYear         = pData:readword()
info.kPlayTime.wMonth        = pData:readword()
info.kPlayTime.wDayOfWeek    = pData:readword()
info.kPlayTime.wDay          = pData:readword()
info.kPlayTime.wHour         = pData:readword()
info.kPlayTime.wMinute       = pData:readword()
info.kPlayTime.wSecond       = pData:readword()
info.kPlayTime.wMilliseconds = pData:readword()


-- 结束时间
info.kPlayTimeEnd = {}
info.kPlayTimeEnd.wYear         = pData:readword()
info.kPlayTimeEnd.wMonth        = pData:readword()
info.kPlayTimeEnd.wDayOfWeek    = pData:readword()
info.kPlayTimeEnd.wDay          = pData:readword()
info.kPlayTimeEnd.wHour         = pData:readword()
info.kPlayTimeEnd.wMinute       = pData:readword()
info.kPlayTimeEnd.wSecond       = pData:readword()
info.kPlayTimeEnd.wMilliseconds = pData:readword()


info.kRecordChilds = {}


local kRecordChildLen = pData:readint()
-- print("kRecordChildLen :",kRecordChildLen)


for i=1,kRecordChildLen do
info.kRecordChilds[i] = self:decodePrivateRandChildRecord(pData)
end


info.iRecordID = pData:readint()
local strlen = pData:readint()
local str = ""
for i=1,strlen do
str = str .. string.char(pData:readbyte())
end
info.kUserDefine = str
info.dwKindID = pData:readdword()
info.dwVersion = pData:readdword()
-- dump(info)
return info
end


local t2Cmd = {}
t2Cmd.__index = t2Cmd
function t2Cmd:__call()
local len = self._len or 0
local data = CCmd_Data:create(len)
for i=1,len do
-- data:pushbyte(self._data:byte(i))
data:pushbyte(self._data[i])
end
data:resetread()
return data
end
function t2Cmd:pushbyte(byte)
self._len = (self._len or 0) + 1
-- self._data = (self._data or "") .. string.char(byte)
self._data = self._data or {}
self._data[self._len] = byte
end
function t2Cmd:getlen()
return self._len or 0
end
-- 解析单局单个战绩
function NetEvent:decodePrivateRandChildRecord(pData)


-- print("decodePrivateRandChildRecord: curlen = ",pData:getcurlen())
-- print("decodePrivateRandChildRecord: getlen = ",pData:getlen())


local kRecordChild = {}


kRecordChild.iRecordID = pData:readint()
kRecordChild.iRecordChildID = pData:readint()


-- print("decodePrivateRandChildRecord iRecordID:",kRecordChild.iRecordID)
-- print("decodePrivateRandChildRecord iRecordChildID:",kRecordChild.iRecordChildID)


kRecordChild.kScores = {}
local kScoreLen = pData:readint()


-- print("decodePrivateRandChildRecord kScoreLen:",kScoreLen)


for i=1,kScoreLen do
kRecordChild.kScores[i] = pData:readint()
end


local kRecordGameLen = pData:readint()


-- print("decodePrivateRandChildRecord kRecordGameLen:",kRecordGameLen)


-- kRecordChild.kRecordGame = CCmd_Data:create(kRecordGameLen)
-- for i=1,kRecordGameLen do
-- kRecordChild.kRecordGame:pushbyte(pData:readbyte())
-- end
-- kRecordChild.kRecordGame:resetread()
--[[
CCmd_Data会自动释放内存，因此不宜长时保存
采用t2Cmd先数据保存，再通过t2Cmd()返回CCmd_Data
]]
kRecordChild.kRecordGame = setmetatable({},t2Cmd)
for i=1,kRecordGameLen do
kRecordChild.kRecordGame:pushbyte(pData:readbyte())
end


kRecordChild.kPlayTime = {}
kRecordChild.kPlayTime.wYear         = pData:readword()
kRecordChild.kPlayTime.wMonth        = pData:readword()
kRecordChild.kPlayTime.wDayOfWeek    = pData:readword()
kRecordChild.kPlayTime.wDay          = pData:readword()
kRecordChild.kPlayTime.wHour         = pData:readword()
kRecordChild.kPlayTime.wMinute       = pData:readword()
kRecordChild.kPlayTime.wSecond       = pData:readword()
kRecordChild.kPlayTime.wMilliseconds = pData:readword()


local strlen = pData:readint()
local str = ""
for i=1,strlen do
str = str .. string.char(pData:readbyte())
end
kRecordChild.kUserDefine = str


kRecordChild.dwKindID = pData:readdword()
kRecordChild.dwVersion = pData:readdword()


-- 用户头像
local wFaceIDLen = pData:readint() or 0
-- print("wFaceIDLen:",wFaceIDLen)
kRecordChild.wFaceIDs = {}
for i=1,wFaceIDLen do
kRecordChild.wFaceIDs[i] = pData:readword()
-- print("kRecordChild.wFaceIDs ",i,kRecordChild.wFaceIDs[i])
end
local dwCustomIDLen = pData:readint() or 0
-- print("dwCustomIDLen:",dwCustomIDLen)
kRecordChild.dwCustomIDs = {}
for i=1,dwCustomIDLen do
kRecordChild.dwCustomIDs[i] = pData:readdword()
end


-- 用户昵称
local kNickNameLen = pData:readint() or 0
-- print("kNickNameLen:",kNickNameLen)
kRecordChild.kNickNames = {}
for i=1,kNickNameLen do
strlen = pData:readint()
str = ""
for i=1,strlen do
str = str .. string.char(pData:readbyte())
end
kRecordChild.kNickNames[i] = str
end


-- 用户ID
local kUserIDLen = pData:readint() or 0
-- print("kUserIDLen:",kUserIDLen)
kRecordChild.kUserIDs = {}
for i=1,kUserIDLen do
kRecordChild.kUserIDs[i] = pData:readint()
end


-- dump(kRecordChild)
return kRecordChild
end


-- 获取用户战绩列表
function NetEvent:sendGetGameRecordList(dwUserID)


assert(dwUserID,"sendGetGameRecordList params error")


local buffer = CCmd_Data:create(4)
buffer:setcmdinfo(yl.MDM_GP_USER_SERVICE,yl.SUB_GP_GAME_RECORD_LIST)
buffer:pushdword(dwUserID)
if not self:sendSocketData(buffer) then
print("获取用户战绩列表失败！")
self:onErrorCallback("获取用户战绩列表失败！",self._tag)
end
end
function NetEvent:onGetGameRecordList(pData)
print("onGetGameRecordList")


local data = self:decodePrivateRandTotalRecordList(pData)
-- dump(data)
return self:onDataCallback(data,self._tag,pData)
end


-- 获取用户战绩
function NetEvent:sendGetGameRecord(dwUserID,dwRecordID)


assert(dwUserID and dwRecordID,"sendGetGameRecordList params error")


local buffer = CCmd_Data:create(8)
buffer:setcmdinfo(yl.MDM_GP_USER_SERVICE,yl.SUB_GP_GAME_RECORD_TOTAL)
buffer:pushdword(dwUserID)
buffer:pushdword(dwRecordID)
if not self:sendSocketData(buffer) then
print("获取用户战绩失败！")
self:onErrorCallback("获取用户战绩失败！",self._tag)
end
end
function NetEvent:onGetGameRecord(pData)
local data = self:decodePrivateRandTotalRecord(pData)
-- dump(data)
return self:onDataCallback(data,self._tag,pData)
end
-- 获取用户详细战绩
function NetEvent:sendGetGameChildRecord(iRecordChildID)
local buffer = CCmd_Data:create(4)
buffer:setcmdinfo(yl.MDM_GP_USER_SERVICE,yl.SUB_GP_GAME_RECORD_CHILD_ID)
buffer:pushdword(iRecordChildID)
if not self:sendSocketData(buffer) then
print("获取用户战绩列表失败！")
self:onErrorCallback("获取用户战绩列表失败！",self._tag)
end
end


function NetEvent:onGetGameChildRecord(pData)
print("onGetGameChildRecord data len:",pData:getlen())


local data = self:decodePrivateRandChildRecord(pData)
-- dump(data)
return self:onDataCallback(data,self._tag,pData)
end


-- 解散房间
function NetEvent:sendDissumeRoom( roomId )
    local buffer = ExternalFun.create_netdata(cmd_pri_login.CMD_MB_SearchServerTable)
    buffer:setcmdinfo(cmd_pri_login.MDM_MB_PERSONAL_SERVICE,cmd_pri_login.SUB_MB_DISSUME_SEARCH_SERVER_TABLE)
    buffer:pushstring(roomId, define_private.ROOM_ID_LEN)
    if not self:sendSocketData(buffer) and nil ~= self._callBack then
        self:onErrorCallback("发送解散房间失败！",self._tag)
    end
end
function NetEvent:onSubDissumeSearchReasult(pData)
local cmd_table = ExternalFun.read_netdata(cmd_pri_login.CMD_MB_DissumeSearchResult, pData)
    dump(cmd_table, "CMD_MB_DissumeSearchResult", 6)


    -- 设置socket登入成功的事件
    self._loginEvent = "dissumeRoom"
    local dwServerID = cmd_table.dwServerID
    self._dwTableID = cmd_table.dwTableID
    return self:LoginPrivRoom(dwServerID)
end


return NetEvent