コード例 #1
0
    public uint dwPathLen;  //路径长度

    public Package GeneratePackage(MasterMsgType masterMsgType, short subMsgType)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterMsgType, (short)subMsgType);
        pkg.Data = PackageHelper.StructToBytes <SMsgActionClientOptMove_CS>(this);
        return(pkg);
    }
コード例 #2
0
    public Package GeneratePackage(MasterMsgType masterType, short subMsg)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterType, subMsg);
        pkg.Data = PackageHelper.StructToBytes <SMsgBattleCommand>(this);

        return(pkg);
    }
コード例 #3
0
    public float DirY;                                          //¡¤??¨°y
    public Package GeneratePackage(MasterMsgType masterType, short subMsg)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterType, subMsg);
        pkg.Data = PackageHelper.StructToBytes <SMsgFightChangeDirect_CS>(this);

        return(pkg);
    }
コード例 #4
0
    public byte[] szKeyMD5;     // 二级密码的 MD5

    public Package GeneratePackage(MasterMsgType masterMsgType, short subMsgType)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterMsgType, (short)subMsgType);
        pkg.Data = BitConverter.GetBytes(this.lActorID)
                   .Concat(szKeyMD5).ToArray();
        return(pkg);
    }
コード例 #5
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);

        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_TRADE:
            switch (package.GetSubMsgType())
            {
            case TradeDefineManager.MSG_TRADE_OPENSHOP:
                AddToInvoker(ReceiveOpenShopHandel, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_PAY_SUCESS:
                AddToInvoker(TradePaySuccessHandle, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_BUYGOODS:
                AddToInvoker(ReceiveShopsBuySuccessHandle, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_QUICK_BUY_GOODS:
                AddToInvoker(ReceiveQuickBuySuccessHandle, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_AUCTION_UI:
                AddToInvoker(ReceiveAuctionHandle, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_AUCTION_GOODS:
                AddToInvoker(ReceiveAuctionResultHandle, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_CARRYSHOP_UI:
                AddToInvoker(CarryShopUIResponseHandle, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_CARRYSHOP_BUY:
                AddToInvoker(CarryShopBuyResponseHandle, package.Data, socketId);
                break;

            case TradeDefineManager.MSG_TRADE_CARRYSHOP_UNLOCK:
                AddToInvoker(CarryShopUnLockResponseHandle, package.Data, socketId);
                break;

            default:
                break;
            }
            break;

        default:
            //TraceUtil.Log("不能识别的主消息" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #6
0
    public Package GeneratePackage(MasterMsgType masterMsgType, short subMsgType)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterMsgType, (short)subMsgType);
        pkg.Data = PackageHelper.GetByteFromArray(szName, 19)
                   .Concat(new byte[] { byKind }).ToArray();
        //TraceUtil.Log("asdfasfjasdgjasd;lgjk" + Encoding.UTF8.GetString(pkg.Data.Take(19).ToArray()) +"  Name:"+ SZName);
        return(pkg);
    }
コード例 #7
0
    public Package GeneratePackage(MasterMsgType masterMsgType, short subMsgType)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterMsgType, (short)subMsgType);
        pkg.Data = BitConverter.GetBytes(this.lUserID)
                   .Concat(BitConverter.GetBytes(lActorID))
                   .Concat(PackageHelper.GetByteFromArray(this.szRandBuf, 128)).ToArray();
        return(pkg);
    }
コード例 #8
0
    //static ContainerService m_Instance;
    //public ContainerService()
    //{
    //    m_Instance = this;
    //}

    //public static ContainerService Instance { get { return m_Instance; } }

    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        Package       package;
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;

        package = PackageHelper.ParseReceiveData(dataBuffer);
        //TraceUtil.Log("EntityService 收到主消息:" + masterMsgType + "  收到子消息:" + package.GetSubMsgType());
        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_CONTAINER:
            switch (package.GetSubMsgType())
            {
            case ContainerDefineManager.MSG_CONTAINER_CREATE:          //S发送创建客户端物品篮到C
                //Debug.LogWarning("收到创建物品栏消息");
                this.AddToInvoker(CreateContainerHandle, package.Data, socketId);
                break;

            case ContainerDefineManager.MSG_CONTAINER_SYNC:          //S发送背包栏物品位置同步到C
                //Debug.LogWarning("收到物品位置同步消息");
                this.AddToInvoker(ContainerSyncHandle, dataBuffer, socketId);
                break;

            case ContainerDefineManager.MSG_CONTAINER_CHANGESIZE:        //s发送修改背包容量
                //Debug.LogWarning("收到背包容量修改消息");
                this.AddToInvoker(ContainerChangeSize, package.Data, socketId);
                break;

            case ContainerDefineManager.MSG_CONTAINER_DOFF:                            //物品出售回复
                this.AddToInvoker(ReceiveContainerDoffMsg, package.Data, socketId);
                break;

            default:
                //TraceUtil.Log("NET_ROOT_CONTAINER:" + package.GetSubMsgType() + "  " + dataBuffer.Length);
                break;
            }
            break;

        //case MasterMsgType.NET_ROOT_THING:
        //    switch (package.GetSubMsgType())
        //    {
        //        case ContainerDefineManager.MSG_ACTION_USEMEDICAMENTRESULT:
        //            break;
        //        case ContainerDefineManager.MSG_CONTAINER_USE:
        //            break;
        //        default:
        //            //TraceUtil.Log("NET_ROOT_CONTAINER:" + package.GetSubMsgType());
        //            break;
        //    }
        //    break;
        default:
            //TraceUtil.Log("不能识别的主消息:" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #9
0
    public Package GeneratePackage(MasterMsgType masterMsgType, short subMsgType)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterMsgType, (short)subMsgType);
        byte[] byCMArray = new byte[] { byCM };
        pkg.Data = PackageHelper.GetByteFromArray(this.szUserName, 33)
                   .Concat(BitConverter.GetBytes(this.PlatformID))
                   .Concat(PackageHelper.GetByteFromArray(this.szPlatformKey, 37))
                   .Concat(BitConverter.GetBytes(this.wServerID))
                   .Concat(byCMArray).ToArray();
        return(pkg);
    }
コード例 #10
0
    public byte  byNum; //?¨²?¨²?¡ì????????

    public Package GenerateInputPackage(MasterMsgType masterMsgType, short subMsgType, long[] targetUids)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterMsgType, subMsgType);
        pkg.Data = PackageHelper.StructToBytes <SMsgFightFightTo>(this);

        for (int i = 0; i < targetUids.Length; i++)
        {
            //pkg.Data = pkg.Data.Concat(PackageHelper.StructToBytes<long>(targetUids[i])).ToArray();
            pkg.Data = pkg.Data.Concat(BitConverter.GetBytes(targetUids[i])).ToArray();
        }
        return(pkg);
    }
コード例 #11
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);

        //TraceUtil.Log("收到聊天主消息" + masterMsgType + "收到子消息" + package.GetSubMsgType());
        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_CHAT:
            switch (package.GetSubMsgType())
            {
            case ChatDefineManager.MSG_CHAT_CURRENT:
                this.AddToInvoker(ReceiveTownMsgHandle, package.Data, socketId);
                break;

            case ChatDefineManager.MSG_CHAT_SYSTEM:
                this.AddToInvoker(ReceiveSystemMsgHandle, package.Data, socketId);
                break;

            case ChatDefineManager.MSG_CHAT_WORLD:
                this.AddToInvoker(ReceiveWorldMsgHandle, package.Data, socketId);
                break;

            case ChatDefineManager.MSG_CHAT_TEAM:
                this.AddToInvoker(ReceiveTeamMsgHandle, package.Data, socketId);
                break;

            case ChatDefineManager.MSG_CHAT_PRIVATE:
                this.AddToInvoker(ReceivePrivateMsgHandle, package.Data, socketId);
                break;

            case ChatDefineManager.MSG_CHAT_SPACE:
                this.AddToInvoker(ReceiveSpaceMsgHandle, package.Data, socketId);
                break;

            case ChatDefineManager.MSG_CHAT_GETITEMTIP:
                this.AddToInvoker(ReceiveGetItemtipHandle, package.Data, socketId);
                break;
            }
            break;

        default:
            //TraceUtil.Log("不能识别的主消息:" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #12
0
    public Package GeneratePackage(MasterMsgType masterMsgType, short subMsgType)
    {
        Package pkg = new Package();

        pkg.Head = new PkgHead((byte)masterMsgType, subMsgType);
        pkg.Data = PackageHelper.GetByteFromArray(m_MACBuf, 128)
                   .Concat(PackageHelper.GetByteFromArray(randChar16_V, 16))
                   .Concat(BitConverter.GetBytes(this.m_dwUserID))
                   .Concat(BitConverter.GetBytes(this.m_dwActorID))
                   .Concat(new byte[] { this.m_byServerID })
                   .Concat(BitConverter.GetBytes(this.m_MapID))
                   .Concat(new byte[] { this.m_byBackServerID })
                   .Concat(BitConverter.GetBytes(this.m_BakMapID))
                   .Concat(PackageHelper.GetByteFromArray(szSerialNO, 20))
                   .Concat(new byte[] { this.m_LinkType })
                   .Concat(new byte[] { this.m_OPType })
                   .Concat(new byte[] { this.m_ViewType })
                   .ToArray();

        return(pkg);
    }
コード例 #13
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);

        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_FRIEND:
            //TraceUtil.Log("收到好友服务器消息:" + package.GetSubMsgType());
            switch (package.GetSubMsgType())
            {
            case FriendDefineManager.MSG_FRIEND_FIND:           //查找好友 根据名称查找玩家详细信息
                ////TraceUtil.Log("FriendService=-++-=收到查找好友消息");
                break;

            case FriendDefineManager.MSG_FRIEND_ADD:            //添加好友消息
                ////TraceUtil.Log("FriendService=-++-=添加好友应答消息");
                this.AddToInvoker(RecvAddFriendHandle, package.Data, socketId);
                break;

            case FriendDefineManager.MSG_FRIEND_DELETE:            //S发送删除好友应答给C
                ////TraceUtil.Log("FriendService=-++-=更新好友列表消息");
                this.AddToInvoker(DelFriendsResultHandle, package.Data, socketId);
                break;

            case FriendDefineManager.MSG_FRIEND_GETLIST:            //S下发好友列表给C
                ////TraceUtil.Log("FriendService=-++-=收到好友列表消息");
                this.AddToInvoker(RecvFriendListHandle, package.Data, socketId);
                break;

            case FriendDefineManager.MSG_FRIEND_GETREQUESTLIST:
                this.AddToInvoker(RecvFriendRequestListHandle, package.Data, socketId);
                break;

            case FriendDefineManager.MSG_STRANGE_GETLIST:            //获取附近玩家列表
                ////TraceUtil.Log("FriendService=-++-=收到附近玩家列表消息");
                this.AddToInvoker(RecvNearbyPlayerListHandle, package.Data, socketId);
                break;

            case FriendDefineManager.MSG_FRIEND_ANSWER_ADD:
                ////TraceUtil.Log("FriendService=-++-=收到加好友拒绝同意列表消息");
                this.AddToInvoker(RecvFriendAnswerHandle, package.Data, socketId);
                break;

            case FriendDefineManager.MSG_FRIEND_REMIND:        //S下发给线上好友上下线提醒
                ////TraceUtil.Log("FriendService=-++-=收到好友上下线消息"); //好友上下线消息
                this.AddToInvoker(RecvFriendRemindHandle, package.Data, socketId);
                break;

            case FriendDefineManager.MSG_FRIEND_UPDATE:
                ////TraceUtil.Log("FriendService=-++-=收到好友更新属性消息");
                this.AddToInvoker(RecvFriendUpdateHandle, package.Data, socketId);
                break;

            default:
                break;
            }
            break;

        default:
            //TraceUtil.Log(SystemModel.Common,TraceLevel.Error,"不能识别好友主消息" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #14
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        try
        {
            Package       package;
            MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
            package = PackageHelper.ParseReceiveData(dataBuffer);
            switch (masterMsgType)
            {
            case MasterMsgType.NET_ROOT_LOGIN:
                switch (package.GetSubMsgType())
                {
                //S发送登录随机数到C
                case RootDefineManager.ROOTLOGIN_SC_MAIN_ENTERCODE:
                    AddToInvoker(this.ReceiveEnterCode, dataBuffer, socketId);
                    break;

                //S发送角色信息到C
                case RootDefineManager.ROOTLOGIN_SC_MAIN_LOGINRES:
                    //if (GameManager.Instance.IsLogin91Version)
                {
                    AddToInvoker(this.NewReceiveLoginRes, dataBuffer, socketId);
                }
                    //else
                    //{
                    //    AddToInvoker(this.ReceiveLoginRes, dataBuffer, socketId);
                    //}
                    break;

                default:
                    //TraceUtil.Log("NET_ROOT_LOGIN:"******"NET_ROOT_SELECTACTOR:" + package.GetSubMsgType());
                    break;
                }
                break;

            default:
                //TraceUtil.Log("不能识别的主消息:" + package.GetMasterMsgType());
                break;
            }
        }
        catch (Exception e)
        {
            TraceUtil.Log(SystemModel.Common, TraceLevel.Error, e.ToString());
        }
    }
コード例 #15
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        Package       package;
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;

        package = PackageHelper.ParseReceiveData(dataBuffer);

        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_TEAM:
        {
            switch (package.GetSubMsgType())
            {
            case TeamDefineManager.MSG_TEAM_TEAMLIST:
                this.AddToInvoker(this.ReceiveTeamListHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_CREATE:
                this.AddToInvoker(this.ReceiveTeamCreateHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_DISBAND:
                this.AddToInvoker(this.ReceiveTeamDisbandHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_UPDATEPROP:
                this.AddToInvoker(this.ReceiveTeamUpdatePropHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_MEMBER_UPDATEPROP:
                this.AddToInvoker(this.ReceiveTeamMemberUpdatePropHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_MEMBER_JOIN:
                this.AddToInvoker(this.ReceiveTeamMemberJoinHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_CAPTAIN_JOIN:
                this.AddToInvoker(this.ReceiveTeamMemberJoinHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_MEMBER_LEAVE:
                this.AddToInvoker(this.ReceiveTeamMemberLeaveHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_MEMBER_KICK:
                this.AddToInvoker(this.ReceiveMemberKickHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_MEMBER_INVITE:
                this.AddToInvoker(this.ReceiveTeamMemberInviteHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_MEMBER_READY:
                this.AddToInvoker(this.ReceiveMemberReadyHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_ERROR_CODE:
                this.AddToInvoker(this.ReceiveTeamErrorCodeHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_TEAM_INVITER_FAILED:
                this.AddToInvoker(this.ReceiveTeamInviterFailedHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_GET_TEAMNUMLIST:
                this.AddToInvoker(this.ReceiveCrusadeTeamNumListHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_MATCHING_CANCEL:
                this.AddToInvoker(this.ReceiveMatchingCancelHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_MATCHING_CONFIRM:
                this.AddToInvoker(ConfirmMatchindHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_PVP_INVITE_FRIEND:                                    //收到邀请PvpReceiveInviteFriendHandle
                this.AddToInvoker(PvpReceiveInviteFriendHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_PVP_ENTER_CONFIRM:                                    //收到加入成功
                this.AddToInvoker(PvpReceiveEnterConfirmHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_PVP_MATCHING_BEGIN:                                    //收到开始匹配通知
                this.AddToInvoker(PvpReceiveBeginMatchHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_PVP_MATCHING_CANCEL:                                    //收到取消匹配通知
                this.AddToInvoker(PvpReceiveCancelMatchHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_PVP_MATCHING_LEAVE:                                    //收到队友离开通知
                this.AddToInvoker(PvpReceiveCancelTeamHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_PVP_MATCHING_SYNINFO:                                    //收到同步队伍通知
                this.AddToInvoker(PvpMatchindSyncHandle, package.Data, socketId);
                break;

            case TeamDefineManager.MSG_PVP_MATCHING_SUCESS:                                    //匹配成功
                this.AddToInvoker(PvpMatchindSyncHandle, package.Data, socketId);
                break;
            }
        } break;

        default:
            //TraceUtil.Log("不能识别的主消息:" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #16
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);

        //TraceUtil.Log("收到装备操作主消息" + masterMsgType + "收到子消息" + package.GetSubMsgType());
        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_GOODSOPERATE:
            switch (package.GetSubMsgType())
            {
            case GoodsOperateDefineManager.MSG_GOODSOPERATE_OPEN_MAKEFACE:
                AddToInvoker(ReceiveGoodsOperate_OpenMakeFaceCommand, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_GOODSOPERATE_SMELT:
                AddToInvoker(ReceiveGoodsOperate_SmeltCommand, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_GOODSOPERATE_OPEN_TREASURE_UI:
                AddToInvoker(ReceiveOpenTreasureUI, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_GOODSOPERATE_MAKE:
                AddToInvoker(ReceiveEquipMakeMsg, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_GOODSOPERATE_CLICK_TREASURE:
                AddToInvoker(ReceiveClickTreasure, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_OPNE_ACTIVE_CHEST_UI:
                AddToInvoker(ReceiveOpenActiveChestUI, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_ACTIVE_VALUE_OPEN_CHEST:
                AddToInvoker(ReceiveOpenChestValue, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_EQUIP_LEVEL_UP:
                AddToInvoker(ReceiveEquipmentUpLevelMsg, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_GOODSOPERATE_BESET:
                AddToInvoker(ReceiveGoodsOperateBesetResults, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_EQUIP_STORE_REMOVE:
                AddToInvoker(ReceiveGoodsOperateRemoveResults, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_STORE_SWALLOW:
                AddToInvoker(ReceiveGoodsOperateSwallowResults, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_LUCKDRAW:
                AddToInvoker(ReceiveSMsgLuckDrawResult_SC, package.Data, socketId);
                break;

            case GoodsOperateDefineManager.MSG_GOODSOPERATE_QUICKSMELT:
                AddToInvoker(ReceiveGoodsOperateQuickSmeltMsg, package.Data, socketId);
                break;

            default:
                break;
            }
            break;
        }
    }
コード例 #17
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;

        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_INTERACT:
            switch (package.GetSubMsgType())
            {
            case InteractDefineManager.INTERACT_MSG_COMMON:
                this.AddToInvoker(InteractCommonHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_NEWBIEGUIDE_DATA:           //瑕佸垵濮嬪寲鍩庨晣瑕佸紑鍚殑涓绘寜閽紝鏂嚎閲嶈仈鍙?
                this.AddToInvoker(MainButtonInitDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_INITTASK:          //initialize tasks
                this.AddToInvoker(InitializeTaskDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_ACCEPTTASK:          //Accept task
                this.AddToInvoker(AcceptTaskDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_UPDATETASK:          //Update task
                this.AddToInvoker(UpdateTaskDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_FINISHTASK:          //Finish task
                this.AddToInvoker(FinishTaskDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_GIVEUPTASK:          //Give up task
                this.AddToInvoker(GiveUpTaskDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_GUIDESTEP:          //鏇存柊鍓湰鍐呭紩瀵兼楠?
                this.AddToInvoker(GuideStepHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_RANKINGLIST_DATA:          //鏇存柊鍓湰鍐呭紩瀵兼楠?
                this.AddToInvoker(GetRankingListDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_GETPLAYERRANKING:
                this.AddToInvoker(GetRankingDetailDataHandle, package.Data, socketId);
                break;

            case CommonMsgDefineManager.INTERACT_MSG_OPEN_UI:
                this.AddToInvoker(this.ReceiveActivityDataHandle, package.Data, socketId);
                break;

            case CommonMsgDefineManager.INTERACT_MSG_GETREWARD:
                this.AddToInvoker(this.ReceiveActivityRewardHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_PVP_MYDATA:
                this.AddToInvoker(this.GetPVPRankingListDataHandle, package.Data, socketId);
                break;

            case InteractDefineManager.INTERACT_MSG_PVP_HISTORY:
                break;

            default:
                break;
            }

            break;

        default:
            break;
        }
    }
コード例 #18
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);

        //TraceUtil.Log("收到副本主消息" + masterMsgType + "收到子消息。" + package.GetSubMsgType());
        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_ECTYPE:
            switch (package.GetSubMsgType())
            {
            //case EctypeDefineManager.MSG_ECTYPE_WORLDMAP_SELECT:
            //    //TraceUtil.Log("收到世界地图创建选择消息");
            //    this.AddToInvoker(WorldMapSelectHandle, dataBuffer, socketId);
            //    break;

            //case EctypeDefineManager.MSG_ECTYPE_ECTYPECONTAINER_LEVELDATAS:
            //    this.AddToInvoker(EctypeLevelDataHandle, dataBuffer, socketId);
            //    //TraceUtil.Log("回应关卡信息!!!!!");
            //    break;

            //case EctypeDefineManager.MSG_ECTYPE_SETTLEACCOUNTS:
            //    this.AddToInvoker(EctypeSettleAccountHandle, dataBuffer, socketId);
            //    //TraceUtil.Log("收到副本结算消息!");
            //    break;

            //case EctypeDefineManager.MSG_ECTYPE_SYN_SKILLDATA:
            //    this.AddToInvoker(ReceiveSkillDataHandle, dataBuffer, socketId);
            //    break;

            //case EctypeDefineManager.MSG_ECTYPE_CREATEERROR:
            //    this.AddToInvoker(EctypeRequestError, dataBuffer, socketId);
            //    //TraceUtil.Log("创建副本失败!!");
            //    break ;
            case ECTYPE_DefineManager.MSG_ECTYPE_SYN_SKILLDATA:
                //TraceUtil.Log("收到技能同步消息");
                this.AddToInvoker(ReceiveSkillDataHandle, dataBuffer, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_SELECT:
                //TraceUtil.Log("收到跳转副本界面消息");
                this.AddToInvoker(EctypeSelectHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_LEVELDATA:
                //TraceUtil.Log("收到单个副本信息");
                this.AddToInvoker(EctypeLevelDataHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_CANENTER_ECTYPE:
                //TraceUtil.Log("所有队友加入副本成功");
                this.AddToInvoker(ResponeTeamateEnterEctype, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_SETTLEACCOUNTS:
                this.AddToInvoker(EctypeSettleAccountHandle, dataBuffer, socketId);
                //TraceUtil.Log("收到副本结算消息!");
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_PLAYERREVIVE:
                this.AddToInvoker(sMSGEctypePlayerReviveHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_TREASUREAWARD:
                //TraceUtil.Log("收到宝箱奖励消息 ");
                this.AddToInvoker(sMSGEctypeTreasureReward_SCHandel, package.Data, socketId);
                break;

            //\
            case ECTYPE_DefineManager.MSG_TEST_BEGIN_LOG:
                this.AddToInvoker(StartPrintHandle, package.Data, socketId);

                break;

            case ECTYPE_DefineManager.MSG_TEST_END_LOG:
                this.AddToInvoker(EndPrintHandle, package.Data, socketId);

                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_ERRORCODE:
                this.AddToInvoker(EctypeErrorCodeHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_CLEARANCE:
                this.AddToInvoker(ECTYPE_CLEARANCEHandle, package.Data, socketId);

                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_PVP_FINDPLAYER:
                this.AddToInvoker(PVPFindPlayerHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_PVP_READY:
                this.AddToInvoker(PVPReadyHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_PVP_FIGHTING:
                this.AddToInvoker(PVPFightingHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_PVP_SETTLEACCOUNTS:
                this.AddToInvoker(PVPSettleAccountHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_INITIALIZE:
                this.AddToInvoker(InitializeEctypeHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_YAOQIPROP:
                this.AddToInvoker(UpdateYaoqiHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_PRACTICE_LIST:        //练功房列表
                this.AddToInvoker(ReceiveMartialArtsRoomList, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_ALLSEAT_INFO:        //同步房间座位信息
                this.AddToInvoker(ReceiveEctypeAllSeatInfo, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_SET_INFO:        //同步座位信息
                this.AddToInvoker(ReceiveUpdateEctypeSeatInfo, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_TRIALS_INFO:        //试炼副本列表
                this.AddToInvoker(ReceiveTrialsEctypeList, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_TRIALS_SUBRESULT:        //试炼副本波数结算
                this.AddToInvoker(ReceiveSingleTrialsSettlement, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_TRIALS_TOTALRESULT:        //试炼副本结算
                this.AddToInvoker(ReceiveTrialsSettlement, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_PRACIICE_YAONVUPDATE:
                //TraceUtil.Log("[ReceivePracticeYaoNvUpdateHandle]");
                this.AddToInvoker(ReceivePracticeYaoNvUpdateHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_SHOW_TIPS:
                this.AddToInvoker(ReceiveMissionFailSettement, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_FIGHT_MODE:
                this.AddToInvoker(EctypeFightModeHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_RESULT:
                this.AddToInvoker(ReceiveBossDeadSettement, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_YAONVSKILL_USETIME:
                this.AddToInvoker(ReceiveYaoNvSkillUseTime, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_OPEN_CHEST:
                this.AddToInvoker(ReceiveTreasureThestsOpenMsg, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_LOOPNUM:
                this.AddToInvoker(ReceiveLoopNumMsg, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_LOOPMAX:
                this.AddToInvoker(ReceiveMaxLoopNUmMsg, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_FINISH:
                this.AddToInvoker(ReceiveEctypeFinishMsg, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_INFO:
                this.AddToInvoker(ReceiveEctypeDefineInfoMsg, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_UPDATA:
                this.AddToInvoker(ReceiveEctypeDefineUpdateMsg, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_MEMBER_UPDATEPROP:
                this.AddToInvoker(ReceiveEctypePropsHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_DEFINE_RESULT:
                this.AddToInvoker(ReceiveDefenceEctypeResultHandle, package.Data, socketId);
                break;

            //常规副本信息
            case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_INFO:
                this.AddToInvoker(ReceiveEctypeNomalDataHandle, package.Data, socketId);
                break;

            //常规副本信息更新
            case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_UPDATA:
                this.AddToInvoker(ReceiveEctypeNomalUpdateHandle, package.Data, socketId);
                break;

            //更新副本宝箱信息
            case ECTYPE_DefineManager.MSG_ECTYPE_NORMAL_UPDATACHEST:
                this.AddToInvoker(ReceiveChessInfoUpdateHandle, package.Data, socketId);
                break;

            //无尽副本波数
            case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_LOOPNUM:
                this.AddToInvoker(ReceiveEndlessLoopNumHandle, package.Data, socketId);
                break;

            //无尽副本获得奖励(无尽副本闯过的波数)
            case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_REWARD:
                this.AddToInvoker(ReceiveEndlessPassLoopHandle, package.Data, socketId);
                break;

            //无尽副本结算
            case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_RESULT:
                this.AddToInvoker(ReceiveEndlessFinishPassLoopHandle, package.Data, socketId);
                break;

            //无尽副本界面数据
            case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_INFO:
                this.AddToInvoker(ReceiveEndlessBestDataHandle, package.Data, socketId);
                break;

            //无尽副本界面数据更新
            case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_UPDATA:
                this.AddToInvoker(ReceiveEndlessBestDataUpdateHandle, package.Data, socketId);
                break;

            //无尽副本断线重连
            case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_LOOPTIME:
                this.AddToInvoker(ReceiveEndlessAgainConnectHandle, package.Data, socketId);
                break;

            //无尽副本跳转场景
            case ECTYPE_DefineManager.MSG_ECTYPE_ENDLESS_MAPJUMPTIME:
                this.AddToInvoker(ReceiveEndlessSceneTimeHandle, package.Data, socketId);
                break;

            //讨伐副本结算
            case ECTYPE_DefineManager.MSG_ECTYPE_CRUSADE_RESULT:
                this.AddToInvoker(ReceiveEctypeCrusadeResultHandle, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_CRUSADE_TIME:
                this.AddToInvoker(ReceiveEctypeCrusadeTime, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_UPDATE_BLOCK:
                this.AddToInvoker(ReceiveEctypeUpdateBlock, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_RESULT_SWEEP:
                this.AddToInvoker(ReceiveEctypeSweepReward, package.Data, socketId);
                break;

            case ECTYPE_DefineManager.MSG_ECTYPE_RANDOM_REWARD:
                this.AddToInvoker(ReceiveEctypeRandomReward, package.Data, socketId);
                break;
                //case ECTYPE_DefineManager.MSG_ECTYPE_PVP_RESULT:
                //	this.AddToInvoker(ReceiveEctypePVPSettlement, package.Data, socketId);
                break;

            default:
                //TraceUtil.Log("NET_ROOT_ECTYPE" + package.GetSubMsgType());
                break;
            }
            break;

        default:
            //TraceUtil.Log("不能识别的主消息" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #19
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);

        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_EMAIL:
            switch (package.GetSubMsgType())
            {
            case EmailDefineManager.MSG_EMAIL_NOREAD_EMAIL:
                AddToInvoker(ReceiveMailLoginState, package.Data, socketId);


                break;

            case EmailDefineManager.MSG_EMAIL_OPEN_UI_TYPE:
                AddToInvoker(ReceiveMailOpenUI, package.Data, socketId);


                break;

            case EmailDefineManager.MSG_EMAIL_UPDATE:
                AddToInvoker(ReceiveMailUpdate, package.Data, socketId);


                break;

            case EmailDefineManager.MSG_EMAIL_SEND:
                AddToInvoker(ReceiveMailSend, package.Data, socketId);
                break;

            case EmailDefineManager.MSG_EAMIL_DEL:
                AddToInvoker(ReceiveMailDel, package.Data, socketId);


                break;

            case EmailDefineManager.MSG_EMAIL_ALLGOODSGET:
                AddToInvoker(ReceiveMailGetGoodsAll, package.Data, socketId);


                break;

            case EmailDefineManager.MSG_EMAIL_ALLDEL:
                AddToInvoker(ReceiveMailDelAll, package.Data, socketId);

                break;

            case EmailDefineManager.MSG_EMAIL_READ:
                AddToInvoker(ReceiveMailRead, package.Data, socketId);

                break;

            default:
                break;
            }
            break;

        default:
            //TraceUtil.Log("不能识别的主消息" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #20
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;
        Package       package       = PackageHelper.ParseReceiveData(dataBuffer);

        //TraceUtil.Log("收到战斗主消息" + masterMsgType + "收到子消息" + package.GetSubMsgType());
        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_FIGHT:
            switch (package.GetSubMsgType())
            {
            case FightDefineManager.MSG_FIGHT_FINISH:
                break;

            case FightDefineManager.MSG_FIGHT_TALK:
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_COMMAND:
                AddToInvoker(ReceiveBattleCommand, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_CALCULATE_EFFECT:
                AddToInvoker(ReceiveBattleCalculateEffect, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_BEAT_BACK:
                AddToInvoker(ReceiveBattleBeatBack, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_UPDATE_BULLET:
                AddToInvoker(ReceiveBattleUpdateBullet, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_BULLET_DESTORY:
                AddToInvoker(ReceiveBattleBulletDestory, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_BREAK_SKILL:
                AddToInvoker(ReceiveBattleBreakSkill, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_UPDATE_BATTERCOUNT:
                AddToInvoker(ReceiveSMsgFightBatterCount, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_UPDATE_KILLCOUNT:
                AddToInvoker(ReceiveSMsgFightKillCount, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_HIT_FLY:
                AddToInvoker(ReceiveFightHitFly, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_TELEPORT:
                AddToInvoker(ReceiveFightTeleport, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_CHANGE_DIRECT:
                AddToInvoker(ReceiveFightChangeDirect, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_ADSORB:
                AddToInvoker(ReceiveBattleBeAdsorb, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_HORDE:           //定身术
                //TraceUtil.Log("收到定身消息");
                AddToInvoker(ReceiveBattleHorde, package.Data, socketId);
                break;
            //case FightDefineManager.MSG_FIGHT_BATTLE_BLOODSUCKING:
            //    TraceUtil.Log("吸血消息");
            //    this.AddToInvoker(BattleBloodSuckingHandle, package.Data, socketId);
            //    break;

            case FightDefineManager.MSG_FIGHT_BATTLE_ADSORPTIONEX:
                AddToInvoker(ReceiveBattleBeAdsorbEx, package.Data, socketId);
                break;

            case FightDefineManager.MSG_FIGHT_BATTLE_COMMAND_SINGLE:
                AddToInvoker(ReceiveBattleCommondSingle, package.Data, socketId);
                break;

            default:
                //TraceUtil.Log("NET_ROOT_FIGHT" + package.GetSubMsgType());
                break;
            }
            break;

        default:
            //TraceUtil.Log("不能识别的主消息" + package.GetMasterMsgType());
            break;
        }
    }
コード例 #21
0
    public override void SaveResponseHandleToInvoke(byte[] dataBuffer, int socketId, byte cmdtype)
    {
        Package       package;
        MasterMsgType masterMsgType = (MasterMsgType)cmdtype;

        package = PackageHelper.ParseReceiveData(dataBuffer);
        //Debug.Log("EntityService 收到主消息:" + masterMsgType + "  收到子消息:" + package.GetSubMsgType());
        switch (masterMsgType)
        {
        case MasterMsgType.NET_ROOT_ERROR:
            LoginManager.Instance.ResetLoginButtonState();      //收到出错,重置登录按钮状态
            switch (package.GetSubMsgType())
            {
            //服务器主动踢人
            case SystemErrorCodeDefine.ERROR_CODE_KICK:
                AddToInvoker(this.ReceiveKickCode, dataBuffer, socketId);
                break;

            //队伍没有找到返回信息
            case SystemErrorCodeDefine.TEAM_CODE_NOLIST:
                AddToInvoker(this.ReceiveNoListHandle, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_SELFHAVETEAM:
                AddToInvoker(this.ReceiveSelfHaveTeamHandle, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.ENTITY_CODE_NOENOUGHBINDPAY:
                AddToInvoker(this.ReceiveNoEnoughBindPayHandle, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.ENTITY_CODE_NOENOUGHACTIVELIFE:        //活力不足
                AddToInvoker(this.ReceiveNoEnoughActivelife, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.GOODS_CODE_PACKETFULL:
                //背包已满
                AddToInvoker(this.ReceivePackageFull, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_NOEXIST:
                AddToInvoker(this.ReceiveTeamNoExist, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_TEAMFULL:
                AddToInvoker(this.ReceiveTeamFull, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_TEAMMEMBERNOREADY:
                AddToInvoker(this.ReceiveTeamMemberNoReady, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_TEAMFIGHTING:
                AddToInvoker(this.ReceiveTeamFighting, dataBuffer, socketId);
                break;

            //创建人物失败 角色名重复
            case SystemErrorCodeDefine.ERROR_CODE_CREATEFAILED_DUPLICATE:
                AddToInvoker(this.ReceiveCreateFailedDuplicate, dataBuffer, socketId);
                break;

            //创建人物失败 角色达到上限
            case SystemErrorCodeDefine.ERROR_CODE_CREATEFAILED_MAXNUM:
                AddToInvoker(this.ReceiveCreateFailedMaxnum, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TRADE_CODE_SALE:
                //出售物品成功
                AddToInvoker(this.ReceiveDiscardContainerGoods, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.ECTYPE_CODE_NOENTERTIMES:
                AddToInvoker(this.ReceiveNoEnterTimesHandle, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.ECTYPE_CODE_PVPREMATCHING:
                AddToInvoker(this.ReceivePVPRematching, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.ECTYPE_CODE_PVPNOTIMES:
                AddToInvoker(this.ReceivePVPNoTimes, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.ECTYPE_CODE_PLAYERLEVEL:        //副本等级不满足
                AddToInvoker(this.ReceiveEctypePlayerLevelError, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.ECTYPE_CODE_ROMMNOFOUND:        //找不到房间
                AddToInvoker(this.ReceiveEctypeCantFindRoom, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.ECTYPE_CODE_PLAYERNUMMAX:        //人数已满
                AddToInvoker(this.ReceiveEctypeRoleFull, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_ECTYPE_UNLOCK:        //关卡未解锁
                AddToInvoker(this.ReceiveEctypeLockError, dataBuffer, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_TEAM_TIMELIMIT:
                AddToInvoker(this.ReceiveTeamTimeLimit, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.CHAT_CODE_FORBID:
                AddToInvoker(this.ReceiveChatForbid, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.CHAT_PLAYER_OFFLINE:
                AddToInvoker(this.ReceiveChatPlayerOffLine, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.FRIEND_CODE_FULL:
                AddToInvoker(this.ReceiveFriendCodeFull, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.FRIEND_CODE_OTHERISFULL:
                AddToInvoker(this.ReceiveOtherFriendCodeFull, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.FIREND_CODE_OFFLINE:
                AddToInvoker(this.ReceiveFriendOffLine, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.FRIEND_CODE_EXIST:
                AddToInvoker(this.ReceiveFriendIsExist, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.TEAM_CODE_TARGETHASTEAM:
                AddToInvoker(this.ReceiveTargetHasTeam, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.FRIEND_CODE_ISOFFLINE:
                AddToInvoker(this.ReceiveFriendIsOffLine, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.ECTYPE_CODE_NOITEM:
                AddToInvoker(this.ReceiveNoItem, package.Data, socketId);
                break;

            case SystemErrorCodeDefine.TRADE_AUCTION_OUTDATE:
                AddToInvoker(this.ReceiveAuctionFailTip, package.Data, socketId);
                break;
                UI.MessageBox.Instance.ShowTips(3, LanguageTextManager.GetString("IDS_I27_20"), 1);

            ////创建人物(登录)失败 账号已登录 倒计时x秒 重新操作(服务器在踢人)
            //case SystemErrorCodeDefine.ERROR_CODE_CREATEFAILED_LOGGEDIN:
            //    AddToInvoker(this.ReceiveCreateFailedLoggedin, dataBuffer, socketId);
            //    break;
            default:
                AddToInvoker(this.ReceiveDefaultErrorCode, dataBuffer, socketId);
                break;
            }
            break;

        default:
            //TraceUtil.Log("不能识别的主消息:" + package.GetMasterMsgType());
            break;
        }
    }