public override void OnOperationResponse(OperationResponse operationResponse)
    {
        SubCode subCode = ParameterTool.GetSubCode(operationResponse.Parameters);

        switch (subCode)
        {
        case SubCode.TeamFight:
            if (operationResponse.ReturnCode == (short)ReturnCode.HavingTeam)      //组队成功
            {
                //Debug.Log("SubCode.TeamFight");
                List <Role> roleList     = ParameterTool.GetParameter <List <Role> >(operationResponse.Parameters, ParameterCode.RoleList);
                int         masterRoleId = ParameterTool.GetParameter <int>(operationResponse.Parameters, ParameterCode.MasterRoleId, false);
                OnHavingTeam(roleList, masterRoleId);
            }
            else if (operationResponse.ReturnCode == (short)ReturnCode.WaitingTeam)      //组队失败
            {
                //Debug.Log("SubCode.TeamFight");
                OnWaitingTeam();
            }
            break;

        case SubCode.CancelTeam:
            //Debug.Log("SubCode.CancelFight");
            OnCancelTeam();
            break;
        }
    }
    public override void OnEventData(EventData data)
    {
        SubCode subCode = ParameterTool.GetSubCode(data.Parameters);

        switch (subCode)
        {
        case SubCode.SyncEnemyCreat:
            //Debug.Log("SubCode.CreatEnemy");
            EnemyCreatModel model = ParameterTool.GetParameter <EnemyCreatModel>(data.Parameters, ParameterCode.CreatEnemy);
            OnSyncEnemyCreat(model);
            break;

        case SubCode.SyncPositionAndRotation:
            //Debug.Log("SubCode.SyncPositionAndRotation");
            EnemyPositionModel model2 = ParameterTool.GetParameter <EnemyPositionModel>(data.Parameters, ParameterCode.EnemyPosition);
            OnSyncEnemyPosition(model2);
            break;

        case SubCode.SyncEnemyAnim:
            //Debug.Log("SubCode.SyncPositionAndRotation");
            EnemyAnimModel model3 = ParameterTool.GetParameter <EnemyAnimModel>(data.Parameters, ParameterCode.EnemyAnim);
            OnSyncEnemyAnim(model3);
            break;
        }
    }
    public override void OnOperationResponse(OperationResponse operationResponse)
    {
        SubCode subCode = ParameterTool.GetSubCode(operationResponse.Parameters);

        switch (subCode)
        {
        case SubCode.GetSkillDBList:
            //Debug.Log("OnGetSkillList");
            List <SkillDB> skillList = ParameterTool.GetParameter <List <SkillDB> >(operationResponse.Parameters, ParameterCode.SkillDBList);
            OnGetSkillList(skillList);
            break;

        case SubCode.AddSkillDB:
            //Debug.Log("OnAddSkillDB");
            SkillDB skillAdd = ParameterTool.GetParameter <SkillDB>(operationResponse.Parameters, ParameterCode.SkillDB);
            OnAddSkillDB(skillAdd);
            break;

        case SubCode.UpgradeSkillDB:
            //Debug.Log("OnUpgradeSkillDB");
            SkillDB skillUpgrade = ParameterTool.GetParameter <SkillDB>(operationResponse.Parameters, ParameterCode.SkillDB);
            OnUpgradeSkillDB(skillUpgrade);
            break;
        }
    }
        public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer)
        {
            SubCode subCode = ParameterTool.GetSubCode(request.Parameters);

            switch (subCode)
            {
            case SubCode.SyncBossAnim:
                RequestTool.TransmitRequest(peer, request, opCode, subCode);
                break;
            }
        }
    public override void OnEventData(EventData data)
    {
        SubCode subCode = ParameterTool.GetSubCode(data.Parameters);

        switch (subCode)
        {
        case SubCode.SyncBossAnim:
            //Debug.Log("SubCode.SyncBossAnim");
            BossAnimModel model = ParameterTool.GetParameter <BossAnimModel>(data.Parameters, ParameterCode.BossAnim);
            OnSyncBossAnim(model);
            break;
        }
    }
        public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer)
        {
            SubCode subCode = ParameterTool.GetSubCode(request.Parameters);

            switch (subCode)
            {
            case SubCode.SyncEnemyCreat:
                TransmitRequest(peer, request, subCode);
                break;

            case SubCode.SyncPositionAndRotation:
                TransmitRequest(peer, request, subCode);
                break;

            case SubCode.SyncEnemyAnim:
                TransmitRequest(peer, request, subCode);
                break;
            }
        }
    public override void OnEventData(EventData data)
    {
        SubCode subCode = ParameterTool.GetSubCode(data.Parameters);

        switch (subCode)
        {
        case SubCode.ConfirmTeam:
            //Debug.Log("SubCode.ConfimTeam");
            List <Role> roleList     = ParameterTool.GetParameter <List <Role> >(data.Parameters, ParameterCode.RoleList);
            int         masterRoleId = ParameterTool.GetParameter <int>(data.Parameters, ParameterCode.MasterRoleId, false);
            OnHavingTeam(roleList, masterRoleId);
            break;

        case SubCode.SyncPositionAndRotation:
            //Debug.Log("SubCode.SyncPlayer");
            int     roleId      = ParameterTool.GetParameter <int>(data.Parameters, ParameterCode.RoleId, false);
            Vector3 position    = ParameterTool.GetParameter <Vector3Object>(data.Parameters, ParameterCode.Position).ToVector3();
            Vector3 eulerAngles = ParameterTool.GetParameter <Vector3Object>(data.Parameters, ParameterCode.EulerAngles).ToVector3();
            OnSyncPositionAndRotation(roleId, position, eulerAngles);
            break;

        case SubCode.SyncMoveAnimation:
            //Debug.Log("SubCode.SyncMoveAnimation");
            int roleId2 = ParameterTool.GetParameter <int>(data.Parameters, ParameterCode.RoleId, false);
            PlayerMoveAnimationModel model2 = ParameterTool.GetParameter <PlayerMoveAnimationModel>(data.Parameters, ParameterCode.MoveAnimation);
            OnSyncMoveAnimation(roleId2, model2);
            break;

        case SubCode.SyncAnimation:
            //Debug.Log("SubCode.SyncAnimation");
            int roleId3 = ParameterTool.GetParameter <int>(data.Parameters, ParameterCode.RoleId, false);
            PlayerAnimationModel model3 = ParameterTool.GetParameter <PlayerAnimationModel>(data.Parameters, ParameterCode.PlayerAnim);
            OnSyncPlayerAnimation(roleId3, model3);
            break;

        case SubCode.SyncGameState:
            //Debug.Log("SubCode.SyncGameState");
            GameStateModel model4 = ParameterTool.GetParameter <GameStateModel>(data.Parameters, ParameterCode.GameState);
            OnSyncGameState(model4);
            break;
        }
    }
        public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
        {
            SubCode subcode = ParameterTool.GetSubCode(request.Parameters);

            ParameterTool.AddSubCode(response.Parameters, subcode);
            switch (subcode)
            {
            case SubCode.AddSkillDB:
                SkillDB skilldb = ParameterTool.GetParameter <SkillDB>(request.Parameters, ParameterCode.SkillDB);
                skilldb.Role = peer.LoginRole;
                skilldbManager.AddSkillDB(skilldb);
                skilldb.Role = null;
                ParameterTool.AddParameter(response.Parameters, ParameterCode.SkillDB, skilldb);
                break;

            case SubCode.GetSkillDBList:
                List <SkillDB> list = skilldbManager.Get(peer.LoginRole);
                foreach (var temp in list)
                {
                    temp.Role = null;
                }
                ParameterTool.AddParameter(response.Parameters, ParameterCode.SkillDBList, list);
                break;

            case SubCode.UpdateSkillDB:
                SkillDB skilldb1 = ParameterTool.GetParameter <SkillDB>(request.Parameters, ParameterCode.SkillDB);
                skilldb1.Role = peer.LoginRole;
                skilldbManager.UpdateSkillDB(skilldb1);

                break;

            case SubCode.UpgradeSkillDB:
                SkillDB skilldb2 = ParameterTool.GetParameter <SkillDB>(request.Parameters, ParameterCode.SkillDB);
                Role    role     = ParameterTool.GetParameter <Role>(request.Parameters, ParameterCode.Role);
                role.User     = peer.LoginUser;
                skilldb2.Role = role;
                skilldbManager.UpgradeSkillDB(skilldb2, role);
                skilldb2.Role = null;
                ParameterTool.AddParameter(response.Parameters, ParameterCode.SkillDB, skilldb2);
                break;
            }
        }
Exemple #9
0
        public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer,
                                              SendParameters sendParameters)
        {
            SubCode subcode = ParameterTool.GetSubCode(request.Parameters);

            switch (subcode)
            {
            case SubCode.CreateEnemy:
                RequestTool.TransmitRequest(peer, request, OpCode);
                break;

            case SubCode.SyncEnemyPosition:
                RequestTool.TransmitRequest(peer, request, OpCode);
                break;

            case SubCode.SyncEnemyAnimation:
                RequestTool.TransmitRequest(peer, request, OpCode);
                break;
            }
        }
        public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer)
        {
            SubCode subCode = ParameterTool.GetSubCode(request.Parameters);

            ParameterTool.AddSubCode(response.Parameters, subCode);
            switch (subCode)
            {
            case SubCode.GetSkillDBList:
                List <SkillDB> listGet = manager.GetSkillDBList(peer.LoginRole);
                foreach (var temp in listGet)
                {
                    temp.Role = null;
                }
                ParameterTool.AddParameter(response.Parameters, ParameterCode.SkillDBList, listGet);
                break;

            case SubCode.AddSkillDB:
                SkillDB skillAdd = ParameterTool.GetParameter <SkillDB>(request.Parameters, ParameterCode.SkillDB);
                Role    roleAdd  = ParameterTool.GetParameter <Role>(request.Parameters, ParameterCode.Role);
                roleAdd.User   = peer.LoginUser;
                peer.LoginRole = roleAdd;
                skillAdd.Role  = roleAdd;
                manager.AddSkill(skillAdd, roleAdd);
                skillAdd.Role = null;
                ParameterTool.AddParameter(response.Parameters, ParameterCode.SkillDB, skillAdd);
                break;

            case SubCode.UpgradeSkillDB:
                SkillDB skillUpgrade = ParameterTool.GetParameter <SkillDB>(request.Parameters, ParameterCode.SkillDB);
                Role    roleUpgrade  = ParameterTool.GetParameter <Role>(request.Parameters, ParameterCode.Role);
                roleUpgrade.User  = peer.LoginUser;
                peer.LoginRole    = roleUpgrade;
                skillUpgrade.Role = roleUpgrade;
                manager.UpgradeSkill(skillUpgrade, roleUpgrade);
                skillUpgrade.Role = null;
                ParameterTool.AddParameter(response.Parameters, ParameterCode.SkillDB, skillUpgrade);
                break;
            }
        }
Exemple #11
0
        public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
        {
            SubCode subcode = ParameterTool.GetSubCode(request.Parameters);

            ParameterTool.AddSubCode(response.Parameters, subcode);
            switch (subcode)
            {
            case SubCode.SendTeam:
                if (TaidouServer.Instance.clientPeersForTeam.Count >= 1)
                {
                    //取得集合中的前两个peer,和当前的peer进行组队
                    ClientPeer peer1 = TaidouServer.Instance.clientPeersForTeam[0];
                    Team       t     = new Team(peer1, peer);
                    TaidouServer.Instance.clientPeersForTeam.RemoveRange(0, 1);
                    List <Role> rolelist = new List <Role>();
                    foreach (var clientPeer in t.ClientPeers)
                    {
                        rolelist.Add(clientPeer.LoginRole);
                    }
                    ParameterTool.AddParameter(response.Parameters, ParameterCode.RoleList, rolelist);
                    ParameterTool.AddParameter(response.Parameters, ParameterCode.MasterRoleID, t.masterRoleID, false);
                    response.ReturnCode = (short)ReturnCode.GetTeam;

                    SendEventByPeer(peer1, (OperationCode)response.OperationCode, SubCode.GetTeam, rolelist, t.masterRoleID);
                }
                else
                {
                    //当前客户端人数不足的时候,把自身加载进来等待组队
                    TaidouServer.Instance.clientPeersForTeam.Add(peer);
                    response.ReturnCode = (short)ReturnCode.WaitTeam;
                }
                break;

            case SubCode.CancelTeam:
                TaidouServer.Instance.clientPeersForTeam.Remove(peer);
                response.ReturnCode = (short)ReturnCode.Success;
                break;

            case SubCode.SyncPositionAndRotation:
                object objPos = null;
                request.Parameters.TryGetValue((byte)ParameterCode.Position, out objPos);
                object objEulerAngle = null;
                request.Parameters.TryGetValue((byte)ParameterCode.EulerAngles, out objEulerAngle);

                foreach (ClientPeer temp in peer.Team.ClientPeers)
                {
                    //向其余的客户端发送请求
                    if (temp != peer)
                    {
                        SendPositionAndRotation(temp, OpCode, SubCode.SyncPositionAndRotation, peer.LoginRole.ID, objPos, objEulerAngle);
                    }
                }

                break;

            case SubCode.SyncPlayerMoveAnimation:

                RequestTool.TransmitRequest(peer, request, OpCode);
                break;

            case SubCode.SyncPlayerAnimation:
                RequestTool.TransmitRequest(peer, request, OpCode);
                break;
            }
        }
Exemple #12
0
        public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer)
        {
            SubCode subCode = ParameterTool.GetSubCode(request.Parameters);

            ParameterTool.AddSubCode(response.Parameters, subCode);
            switch (subCode)
            {
            case SubCode.TeamFight:
                if (GodApplication.Instance.peerListForTeam.Count >= 2)      //三个人可以组队
                {
                    //取得待组队list中的前两个peer和当前的peer组队
                    ClientPeer peer1 = GodApplication.Instance.peerListForTeam[0];
                    ClientPeer peer2 = GodApplication.Instance.peerListForTeam[1];

                    Team team = new Team(peer1, peer2, peer);
                    GodApplication.Instance.peerListForTeam.RemoveRange(0, 2);      //将0 1 2号peer移出待组队集合
                    List <Role> roleList = new List <Role>();
                    foreach (var clientPeer in team.clientPeers)
                    {
                        roleList.Add(clientPeer.LoginRole);
                    }
                    ParameterTool.AddParameter(response.Parameters, ParameterCode.RoleList, roleList);
                    ParameterTool.AddParameter(response.Parameters, ParameterCode.MasterRoleId, team.masterRoleId, false);
                    response.ReturnCode = (short)ReturnCode.HavingTeam;

                    SendMasterIdToPeer(peer1, (OperationCode)request.OperationCode, SubCode.ConfirmTeam, team.masterRoleId, roleList);
                    SendMasterIdToPeer(peer2, (OperationCode)request.OperationCode, SubCode.ConfirmTeam, team.masterRoleId, roleList);
                }
                else      //不足三人
                {
                    //当前服务器可供组队的客户端不足的时候,将自身添加到集合中等待组队
                    GodApplication.Instance.peerListForTeam.Add(peer);
                    response.ReturnCode = (short)ReturnCode.WaitingTeam;
                }
                break;

            case SubCode.CancelTeam:
                GodApplication.Instance.peerListForTeam.Remove(peer);
                response.ReturnCode = (short)ReturnCode.Success;
                break;

            case SubCode.SyncPositionAndRotation:
                object position = null;
                request.Parameters.TryGetValue((byte)ParameterCode.Position, out position);
                object eulerAngles = null;
                request.Parameters.TryGetValue((byte)ParameterCode.EulerAngles, out eulerAngles);
                foreach (var peerTemp in peer.Team.clientPeers)
                {
                    if (peerTemp != peer)      //其他客户端需要同步
                    {
                        SendPositionAndRotationToPeer(peerTemp, (OperationCode)request.OperationCode, SubCode.SyncPositionAndRotation, peer.LoginRole.Id, position, eulerAngles);
                    }
                }
                break;

            case SubCode.SyncMoveAnimation:
                foreach (var peerTemp in peer.Team.clientPeers)
                {
                    if (peerTemp != peer)      //其他客户端需要同步
                    {
                        SendMoveAnimationToPeer(peerTemp, (OperationCode)request.OperationCode, SubCode.SyncAnimation, peer.LoginRole.Id, request.Parameters);
                    }
                }
                break;

            case SubCode.SyncAnimation:
                request.Parameters.Add((byte)ParameterCode.RoleId, peer.LoginRole.Id);
                RequestTool.TransmitRequest(peer, request, opCode, subCode);
                break;

            case SubCode.SyncGameState:
                RequestTool.TransmitRequest(peer, request, opCode, subCode);
                peer.Team.Dismiss();      //解散队伍
                break;
            }
        }