コード例 #1
0
        private void OnConnected(long conn_idx)
        {
            Log.Info("open conn session:" + conn_idx);

            ConnAppProc app_server;

            if (m_app_servers.TryGetValue(conn_idx, out app_server))
            {
                Log.Info("发送内部服务器连接请求:" + app_server.srv_info.srv_type);
                inner.ReqLogin msg = PacketPools.Get(inner.msg.REQ_LOGIN) as inner.ReqLogin;
                msg.srv_info.srv_type          = eServerType.FIGHT;
                msg.srv_info.srv_uid           = m_srv_uid;
                msg.srv_info.srv_endpoint.ip   = SocketUtils.IpToInt(ServerConfig.net_info.ip_for_server);//告诉其他服,战斗服的ip和端口
                msg.srv_info.srv_endpoint.port = ServerConfig.net_info.port_for_server;
                this.Send(conn_idx, msg);
            }
            else
            {
                Log.Warning("未找到连接:" + conn_idx);
            }
        }
コード例 #2
0
        /// <summary>
        /// 网络事件处理
        /// </summary>
        public void OnNetworkServer(ushort header, ByteArray data)
        {
            PacketBase packet = PacketPools.Get(header);

            packet.Read(data);

            MsgProcFunction fun;

            if (m_msg_proc.TryGetValue(packet.header, out fun))
            {
                try
                {
                    fun(packet);
                }
                catch (Exception e)
                {
                    Log.Exception(e);
                }
            }
            PacketPools.Recover(packet);
        }
コード例 #3
0
        /// <summary>
        /// 加密
        /// </summary>
        private void OnClientEncrypt(long conn_idx, PacketBase packet)
        {
            if (!ClientSessionManager.Instance.HasAcceptSession(conn_idx))
            {
                return;
            }

            c2gs.EncryptInfo msg = packet as c2gs.EncryptInfo;

            //版本验证
            byte   main_version;
            byte   sub_version;
            ushort revision_version;

            GlobalID.SplitVersion(msg.version, out main_version, out sub_version, out revision_version);
            if (main_version != GlobalID.VERSION_MAIN)
            {
                ClientSessionManager.Instance.KickoutSession(conn_idx);
                return;
            }
            GlobalID.SetClientVersion(msg.version);

            //收到正常的握手协议后,才加入正式session列表
            ClientSession session = ClientSessionManager.Instance.AddSession(conn_idx);

            if (session != null)
            {
                ClientSessionManager.Instance.CleanupAcceptSession(conn_idx);
                session.session_status = eSessionStatus.CREATED;

                gs2c.EncryptInfo rep_msg = PacketPools.Get(gs2c.msg.ENCRYPT) as gs2c.EncryptInfo;
                rep_msg.key   = PacketEncrypt.Encrypt_Key;
                rep_msg.flags = 0;
                session.Send(rep_msg);
            }
            else
            {
                ClientSessionManager.Instance.KickoutSession(conn_idx);
            }
        }
コード例 #4
0
        /// <summary>
        /// 读邮件
        /// </summary>
        public void HandleReadMail(long mail_idx)
        {
            Player player = UnitManager.Instance.GetUnitByIdx(m_char_idx) as Player;

            if (player == null)
            {
                return;
            }
            MailInfo mail_info;

            if (m_all_mails.TryGetValue(mail_idx, out mail_info))
            {
                if (m_del_mails.Contains(mail_idx))
                {
                    return;
                }

                //是否全服邮件
                if (mail_info.receiver_idx == 0)
                {
                    if (!m_had_recv_mails.Contains(mail_idx))
                    {//同步到db,已经领取过全局邮件
                        m_had_recv_mails.Add(mail_idx);
                        SQLMailHandle.UpdateCharRecvs(m_char_idx, m_had_recv_mails, player.db_id);
                    }
                }
                else if (!Utils.HasFlag(mail_info.flags, (uint)eMailFlags.READED))
                {//修改标记
                    mail_info.flags = Utils.InsertFlag(mail_info.flags, (uint)eMailFlags.READED);
                    m_save_mails.Add(mail_idx);
                    m_is_dirty = true;
                }

                //通知客户端
                ss2c.MailRead msg_client = PacketPools.Get(ss2c.msg.MAIL_READ) as ss2c.MailRead;
                msg_client.mail_info.Copy(mail_info);
                ServerNetManager.Instance.SendProxy(player.client_uid, msg_client);
            }
        }
コード例 #5
0
        private void ProcessWrite(MailWriteInfo info)
        {
            PlayerCache player = PlayerCacheManager.Instance.GetMember(m_char_idx);

            if (player == null)
            {
                return;
            }

            if (info.receiver_idx <= 0)
            {
                Log.Warning("错误的收件人id:" + info.receiver_idx);
                return;
            }
            //存db
            MailInfo mail_info = CommonObjectPools.Spawn <MailInfo>();

            mail_info.mail_type     = eMailType.NORMAL;
            mail_info.spid          = 0;//普通邮件,不区分渠道id
            mail_info.receiver_idx  = info.receiver_idx;
            mail_info.sender_idx    = m_char_idx;
            mail_info.sender_name   = player.ss_data.char_name;
            mail_info.send_time     = Time.second_time;
            mail_info.expire_time   = 0;
            mail_info.delivery_time = 0;
            mail_info.flags         = (uint)eMailFlags.NONE;
            mail_info.subject       = info.subject;
            mail_info.bin_mail_content.content_type = eMailContentType.NORMAL;
            mail_info.bin_mail_content.bin_normal_content.content = info.content;
            SQLMailHandle.CreateMail(mail_info);
            CommonObjectPools.Despawn(mail_info);

            //返回结果给ss
            db2ss.MailCommand rep_msg = PacketPools.Get(db2ss.msg.MAIL_COMMAND) as db2ss.MailCommand;
            rep_msg.mail_idx     = 0;
            rep_msg.command_type = eMailCommandType.WRITE_MAIL;
            rep_msg.error_type   = eMailCommandError.NONE;
            ForServerNetManager.Instance.Send(player.ss_uid, rep_msg);
        }
コード例 #6
0
        private void SendAOIMove(long char_idx, long move_unit_idx, int row, int col)
        {
            Player player = UnitManager.Instance.GetUnitByIdx(char_idx) as Player;

            if (player == null)
            {
                return;
            }
            Unit move_unit = UnitManager.Instance.GetUnitByIdx(move_unit_idx);

            if (move_unit == null)
            {
                return;
            }

            ss2c.UnitMove rep_msg = PacketPools.Get(ss2c.msg.UNIT_MOVE) as ss2c.UnitMove;
            rep_msg.unit_idx.Set(move_unit.unit_type, 0, move_unit.obj_idx);
            rep_msg.pos.Set(col, row);
            rep_msg.flags = 0;
            ServerNetManager.Instance.SendProxy(player.client_uid, rep_msg, false);
            PacketPools.Recover(rep_msg);
        }
コード例 #7
0
        /// <summary>
        /// 登录
        /// </summary>
        private void OnClientLogin(PacketBase packet)
        {
            ws2gs.ClientLogin msg = packet as ws2gs.ClientLogin;

            ///1.查询完成,确认这个过程中是否已经退出
            ClientSession session = ClientSessionManager.Instance.GetSession(msg.client_uid.conn_idx);

            if (session == null)
            {
                return;
            }

            ///2.修改状态
            if (msg.login_result == eLoginResult.E_SUCCESS)
            {
                //更新数据
                session.account_idx    = msg.account_idx;
                session.spid           = msg.spid;
                session.ss_uid         = msg.ss_uid;
                session.session_status = eSessionStatus.ALREADY_LOGIN;
                ClientSessionManager.Instance.AddSessionByAccount(session.account_idx, session.conn_idx);
            }
            else
            {
                session.session_status = eSessionStatus.LOGIN_FAILED;
                //是否超过验证次数:是的话直接踢号
                session.login_error_count += 1;
                if (session.login_error_count >= 5)
                {
                    ClientSessionManager.Instance.KickoutSession(session.conn_idx);
                    return;
                }
            }

            ///3.告诉客户端
            gs2c.ClientLogin rep_msg = PacketPools.Get(gs2c.msg.CLIENT_LOGIN) as gs2c.ClientLogin;
            rep_msg.login_result = msg.login_result;
            session.Send(rep_msg);
        }
コード例 #8
0
        private void OnConnected(long conn_idx)
        {
            Log.Info("Open session:" + conn_idx);

            ConnAppProc app_server;

            if (m_app_servers.TryGetValue(conn_idx, out app_server))
            {
                Log.Info("发送内部服务器连接请求:" + app_server.srv_info.srv_type);
                inner.ReqLogin msg = PacketPools.Get(inner.msg.REQ_LOGIN) as inner.ReqLogin;
                msg.srv_info.srv_type          = eServerType.SERVER;
                msg.srv_info.srv_realm_idx     = m_srv_realm_idx;
                msg.srv_info.srv_uid           = m_srv_uid;
                msg.srv_info.srv_endpoint.ip   = 0;//逻辑服只连接其他服,不需要设置
                msg.srv_info.srv_endpoint.port = 0;
                this.Send(conn_idx, msg);
            }
            else
            {
                Log.Warning("未找到连接:" + conn_idx);
            }
        }
コード例 #9
0
        /// <summary>
        /// 移除关系
        /// </summary>
        public void RemoveRelationCommand(long target_char_idx)
        {
            //不在线了
            Unit player = UnitManager.Instance.GetUnitByIdx(m_char_idx);

            if (player == null)
            {
                return;
            }

            //是否已经存在关系
            RelationInfo relation_info = null;

            if (m_relations.TryGetValue(target_char_idx, out relation_info))
            {
                this.RemoveRelation(target_char_idx);

                //通知逻辑服,由逻辑服转发给客户端
                gl2ss.RelationRemove msg_remove = PacketPools.Get(gl2ss.msg.RELATION_REMOVE) as gl2ss.RelationRemove;
                msg_remove.char_idx   = m_char_idx;
                msg_remove.target_idx = target_char_idx;
                ForServerNetManager.Instance.Send(player.ss_srv_uid, msg_remove);

                //添加到db,需要先判断数据库是否已经有写入过,防止重复写入
                SQLRelationHandle.QueryExistsRelationEvent(m_char_idx, target_char_idx, relation_info.flags, (event_idx) =>
                {
                    if (event_idx == 0 && m_char_idx > 0)
                    {//保存事件
                        RelationEventInfo e_info = new RelationEventInfo();
                        e_info.target_char_idx   = target_char_idx;
                        e_info.source_char_idx   = m_char_idx;
                        e_info.event_type        = eRelationEvent.Delete;
                        SQLRelationHandle.InsertRelationEvent(e_info);
                        //立刻通知接受者
                        this.BroadcastEvent(e_info.target_char_idx, e_info.event_type);
                    }
                });
            }
        }
コード例 #10
0
        /// <summary>
        /// 处理登出逻辑
        /// </summary>
        private void HandleLogoutAccount(ClientUID client_uid)
        {
            Player player = UnitManager.Instance.GetPlayerByClientUID(client_uid) as Player;

            if (player == null)
            {//如果在加载完角色信息前退出,则不会有unit
                return;
            }
            long   char_idx = player.char_idx;
            ushort fs_uid   = player.fs_uid;

            //从场景移除
            BaseScene scene = SceneManager.Instance.GetScene(player.scene_obj_idx);

            if (scene != null)
            {
                scene.RemoveUnit(player);
            }
            //从管理器移除
            UnitManager.Instance.RemoveUnit(player);


            //告诉fs
            ss2fs.LogoutClient fs_msg = PacketPools.Get(ss2fs.msg.LOGOUT_CLIENT) as ss2fs.LogoutClient;
            fs_msg.char_idx = char_idx;
            ServerNetManager.Instance.Send2FS(fs_uid, fs_msg);

            //告诉ws
            ss2ws.LogoutClient ws_msg = PacketPools.Get(ss2ws.msg.LOGOUT_CLIENT) as ss2ws.LogoutClient;
            ws_msg.char_idx = char_idx;
            ServerNetManager.Instance.Send2WS(ws_msg);

            //告诉gl
            ss2gl.LogoutClient gl_msg = PacketPools.Get(ss2gl.msg.LOGOUT_CLIENT) as ss2gl.LogoutClient;
            gl_msg.char_idx = char_idx;
            ServerNetManager.Instance.Send2GL(gl_msg);
        }
コード例 #11
0
 /// <summary>
 /// 压力测试
 /// </summary>
 private void OnClientRobotTest(ClientSession session, PacketBase packet)
 {
     c2gs.RobotTest msg = packet as c2gs.RobotTest;
     if (Utils.HasFlag(msg.flags, (uint)eServerType.WORLD))
     {
         gs2ws.RobotTest rep_msg = PacketPools.Get(gs2ws.msg.ROBOT_TEST) as gs2ws.RobotTest;
         rep_msg.client_uid = session.client_uid;
         rep_msg.length     = msg.length;
         ServerNetManager.Instance.Send2WS(rep_msg);
     }
     if (Utils.HasFlag(msg.flags, (uint)eServerType.SERVER))
     {
         gs2ss.RobotTest rep_msg = PacketPools.Get(gs2ss.msg.ROBOT_TEST) as gs2ss.RobotTest;
         rep_msg.client_uid = session.client_uid;
         rep_msg.length     = msg.length;
         session.Send2SS(rep_msg);
     }
     if (msg.flags == 0 || Utils.HasFlag(msg.flags, (uint)eServerType.GATE))
     {
         gs2c.RobotTest rep_msg = PacketPools.Get(gs2c.msg.ROBOT_TEST) as gs2c.RobotTest;
         rep_msg.length = msg.length;
         session.Send(rep_msg);
     }
 }
コード例 #12
0
        private void OnCharacterInfoLoaded(ClientUID client_uid, InterServerID server_uid, long char_idx)
        {
            PlayerCache member = PlayerCacheManager.Instance.GetMember(char_idx);

            if (member == null)
            {
                Log.Warning("OnPlayerInfoLoaded - 未找到玩家缓存信息:" + char_idx);
                return;
            }
            //设置服务器信息
            member.client_uid = client_uid;
            member.ss_uid     = server_uid.ss_uid;
            member.UpdateAttribute(eUnitModType.UMT_time_last_login, Time.second_time);

            //返回数据给ss
            db2ss.CharacterInfo rep_msg = PacketPools.Get(db2ss.msg.CHARACTER_INFO) as db2ss.CharacterInfo;
            rep_msg.server_uid = server_uid;
            rep_msg.client_uid = client_uid;
            rep_msg.data.Copy(member.ss_data);
            this.Send(rep_msg);

            //读取邮件
            MailCacheManager.Instance.LoadMailbox(member.char_idx);
        }
コード例 #13
0
        private void SendAOIEnter(long char_idx, long enter_unit_idx, int row, int col)
        {
            Player player = UnitManager.Instance.GetUnitByIdx(char_idx) as Player;

            if (player == null)
            {
                return;
            }
            Unit enter_unit = UnitManager.Instance.GetUnitByIdx(enter_unit_idx);

            if (enter_unit == null)
            {
                return;
            }

            //广播aoi消息
            ss2c.UnitEnterAOI rep_msg = PacketPools.Get(ss2c.msg.ENTER_AOI) as ss2c.UnitEnterAOI;
            rep_msg.unit_idx.Set(enter_unit.unit_type, 0, enter_unit.obj_idx);
            rep_msg.pos       = new Position2D(col, row);
            rep_msg.dir       = eDirection.TOP;
            rep_msg.flags     = 0;
            rep_msg.unit_info = enter_unit.GetUnitAOIInfo();
            ServerNetManager.Instance.SendProxy(player.client_uid, rep_msg, false);
        }
コード例 #14
0
        /// <summary>
        /// 网络事件处理
        /// </summary>
        public void OnNetworkClient(long conn_idx, ushort header, ByteArray data)
        {
            ClientSession session = ClientSessionManager.Instance.GetSession(conn_idx);

            if (session != null)
            {
                ///1.判断cd
                if (!session.CheckCooldown(header))
                {
                    //Log.Debug("协议cd不够:" + header);
                    return;
                }

                ///2.消息解密
                if (GlobalID.ENABLE_PACKET_ENCRYPT)
                {
                    //id有效性校验
                    uint packet_idx = data.ReadUInt();
                    packet_idx = PacketEncrypt.DecrpytPacketIndex(packet_idx, PacketEncrypt.Encrypt_Key);
                    if (packet_idx < session.last_packet_idx)
                    {
                        Log.Warning("协议索引校验失败conn_idx:" + conn_idx + " header:" + header);
                        ClientSessionManager.Instance.KickoutSession(conn_idx);
                        return;
                    }
                    session.last_packet_idx = packet_idx;

                    //验证数据的有效性:防止被修改
                    ushort send_verify_data = data.ReadUShort();
                    ushort verify_data      = PacketEncrypt.CalcPacketDataVerify(data.Buffer, 6, data.Available, packet_idx, PacketEncrypt.Encrypt_Key);
                    if (send_verify_data != verify_data)
                    {
                        Log.Warning("数据有效性校验失败conn_idx:" + conn_idx + " header:" + header);
                        ClientSessionManager.Instance.KickoutSession(conn_idx);
                        return;
                    }
                }

                ///3.是否转发消息
                if (header >= ProtocolID.MSG_BASE_C2SS && header < ProtocolID.MSG_BASE_C2SS + ProtocolID.MSG_APPLAYER_PER_INTERVAL)
                {
                    HandleProxyMsgToSS(session, header, data);
                }
                else if (header >= ProtocolID.MSG_BASE_C2WS && header < ProtocolID.MSG_BASE_C2WS + ProtocolID.MSG_APPLAYER_PER_INTERVAL)
                {
                    HandleProxyMsgToWS(session, header, data);
                }
                else if (header >= ProtocolID.MSG_BASE_C2FS && header < ProtocolID.MSG_BASE_C2FS + ProtocolID.MSG_APPLAYER_PER_INTERVAL)
                {
                    HandleProxyMsgToFS(session, header, data);
                }
                else
                {
                    PacketBase packet = PacketPools.Get(header);
                    packet.Read(data);

                    MsgProcFunction fun;
                    if (m_msg_proc.TryGetValue(packet.header, out fun))
                    {
                        try
                        {
                            fun(session, packet);
                        }
                        catch (Exception e)
                        {
                            Log.Exception(e);
                        }
                    }
                    else
                    {
                        Log.Warning("未注册消息处理函数id:" + header);
                    }
                    PacketPools.Recover(packet);
                }
            }
            else
            {
                PacketBase packet = PacketPools.Get(header);
                packet.Read(data);
                switch (packet.header)
                {
                case c2gs.msg.ENCRYPT:
                    OnClientEncrypt(conn_idx, packet);
                    break;

                default:    //没有session,又不是握手协议,说明发错协议了,直接踢掉
                    ClientSessionManager.Instance.KickoutSession(conn_idx);
                    break;
                }
                PacketPools.Recover(packet);
            }
        }
コード例 #15
0
 /// <summary>
 /// 收取邮件附件
 /// </summary>
 public static void SendTakeMail(long mail_idx)
 {
     c2ss.MailTake msg = PacketPools.Get(c2ss.msg.MAIL_TAKE) as c2ss.MailTake;
     msg.mail_idx = mail_idx;
     ClientNetManager.Instance.Send(msg);
 }
コード例 #16
0
 /// <summary>
 /// 移除关系
 /// </summary>
 public static void SendRelationRemove(long char_idx)
 {
     c2ss.RelationRemove msg = PacketPools.Get(c2ss.msg.RELATION_REMOVE) as c2ss.RelationRemove;
     msg.target_char_idx = char_idx;
     ClientNetManager.Instance.Send(msg);
 }
コード例 #17
0
        /// <summary>
        /// 添加关系
        /// </summary>
        /// <param name="target">目标</param>
        /// <param name="flag">关系标记</param>
        public void AddRelationClient(RelationAddTarget target, eRelationFlag flag, string message)
        {
            Player player = UnitManager.Instance.GetUnitByIdx(m_char_idx) as Player;

            if (player == null)
            {
                return;
            }

            //超过上限
            if (IsRelationFull(flag))
            {
                return;
            }

            //判断是否已经存在关系
            if (target.type == eRelationAddType.Idx)
            {
                RelationInfo relation_info;
                if (m_relations.TryGetValue(target.char_idx, out relation_info))
                {
                    //已经存在相同关系,或黑名单状态加好友
                    if (relation_info.flags == flag || (relation_info.flags == eRelationFlag.Block && flag == eRelationFlag.Friend))
                    {
                        return;
                    }
                }
            }
            else
            {
                foreach (var relation_info in m_relations)
                {
                    if (relation_info.Value.char_name == target.char_name)
                    {
                        //已经存在相同关系,或黑名单状态加好友
                        if (relation_info.Value.flags == flag || (relation_info.Value.flags == eRelationFlag.Block && flag == eRelationFlag.Friend))
                        {
                            return;
                        }
                    }
                }
            }

            //是否已经请求过
            long last_add_time = 0;

            if (m_add_relations.TryGetValue(target, out last_add_time))
            {
                if (Time.timeSinceStartup - last_add_time < relation.ADD_RELATION_TIME_OFFSET * 1000)
                {
                    return;
                }
                m_add_relations.Remove(target);
            }

            //发送到gl
            ss2gl.RelationAdd msg = PacketPools.Get(ss2gl.msg.RELATION_ADD) as ss2gl.RelationAdd;
            msg.char_idx  = m_char_idx;
            msg.target_id = target;
            msg.flag      = flag;
            msg.message   = message;
            ServerNetManager.Instance.Send2GL(msg);

            //添加到请求队列
            m_add_relations.Add(target, Time.timeSinceStartup);
        }
コード例 #18
0
 /// <summary>
 /// 请求服务器时间
 /// </summary>
 public static void SendServerTime()
 {
     c2ws.ServerTime msg = PacketPools.Get(c2ws.msg.SERVER_TIME) as c2ws.ServerTime;
     ClientNetManager.Instance.Send(msg);
 }
コード例 #19
0
 /// <summary>
 /// 删除邮件
 /// </summary>
 public static void SendDeleteMail(long mail_idx)
 {
     c2ss.MailDelete msg = PacketPools.Get(c2ss.msg.MAIL_DELETE) as c2ss.MailDelete;
     msg.mail_list.Add(mail_idx);
     ClientNetManager.Instance.Send(msg);
 }
コード例 #20
0
        /// <summary>
        /// 处理关系事件
        /// </summary>
        private void HandleRelationEvent(List <RelationEventInfo> list_event)
        {
            //查询过程中如果下线
            if (m_char_idx == 0)
            {
                return;
            }

            Unit player = UnitManager.Instance.GetUnitByIdx(m_char_idx);

            if (player == null)
            {
                return;
            }

            foreach (var relation_evt in list_event)
            {
                switch (relation_evt.event_type)
                {
                case eRelationEvent.Add:    //对方申请加你好友
                {
                    //超过上限
                    if (IsRelationFull(relation_evt.bin_content.bin_add_content.flag))
                    {
                        //清除处理过的事件
                        SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                        continue;
                    }

                    //是否已经存在相同关系
                    RelationInfo relation_info = null;
                    if (m_relations.TryGetValue(relation_evt.source_char_idx, out relation_info) && relation_info.flags == relation_evt.bin_content.bin_add_content.flag)
                    {
                        //清除处理过的事件
                        SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                        continue;
                    }

                    //拉黑不需要同意,所以不添加事件
                    if (relation_evt.bin_content.bin_add_content.flag == eRelationFlag.Block)
                    {
                        if (m_relations.TryGetValue(relation_evt.source_char_idx, out relation_info))
                        {        //已经存在其他关系,则用新关系覆盖旧关系
                            relation_info.flags = eRelationFlag.Block;
                            this.SyncRelation2SS(relation_evt.source_char_idx);
                        }
                        else
                        {
                            Unit target_player = UnitManager.Instance.GetUnitByIdx(relation_evt.source_char_idx);
                            if (target_player == null)
                            {
                                PlayerInfoForGL data = CommonObjectPools.Spawn <PlayerInfoForGL>();
                                SQLCharHandle.QueryCharacterInfo(relation_evt.source_char_idx, data, (ret) =>
                                    {
                                        if (ret && m_char_idx > 0)
                                        {
                                            relation_info = CommonObjectPools.Spawn <RelationInfo>();
                                            relation_info.Copy(data);
                                            relation_info.flags = eRelationFlag.Block;
                                            this.AddRelation(relation_info);
                                            this.SyncRelation2SS(relation_evt.source_char_idx);
                                        }
                                        CommonObjectPools.Despawn(data);
                                    });
                            }
                            else
                            {
                                relation_info = CommonObjectPools.Spawn <RelationInfo>();
                                relation_info.Copy(target_player.player_data);
                                relation_info.flags = eRelationFlag.Block;
                                this.AddRelation(relation_info);
                                this.SyncRelation2SS(relation_evt.source_char_idx);
                            }
                        }

                        //清除处理过的事件
                        SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                        m_relation_events.Remove(relation_evt.event_idx);
                    }
                    else
                    {
                        //添加关系事件
                        if (m_relation_events.ContainsKey(relation_evt.event_idx))
                        {
                            continue;
                        }
                        else
                        {
                            m_relation_events.Add(relation_evt.event_idx, relation_evt);
                        }

                        //通知逻辑服,由逻辑服转发给客户端
                        gl2ss.RelationAdd msg = PacketPools.Get(gl2ss.msg.RELATION_ADD) as gl2ss.RelationAdd;
                        msg.event_idx = relation_evt.event_idx;
                        msg.char_idx  = m_char_idx;
                        msg.player_id.Set(relation_evt.source_char_idx, relation_evt.bin_content.bin_add_content.char_name);
                        msg.message = relation_evt.bin_content.bin_add_content.message;
                        msg.flag    = relation_evt.bin_content.bin_add_content.flag;
                        ForServerNetManager.Instance.Send(player.ss_srv_uid, msg);
                    }
                    break;
                }

                case eRelationEvent.Delete:    //对方删除了你
                {
                    if (m_relations.ContainsKey(relation_evt.source_char_idx))
                    {
                        this.RemoveRelation(relation_evt.source_char_idx);

                        //通知逻辑服,由逻辑服转发给客户端
                        gl2ss.RelationRemove msg_remove = PacketPools.Get(gl2ss.msg.RELATION_REMOVE) as gl2ss.RelationRemove;
                        msg_remove.char_idx   = m_char_idx;
                        msg_remove.target_idx = relation_evt.source_char_idx;
                        ForServerNetManager.Instance.Send(player.ss_srv_uid, msg_remove);
                    }

                    //清除处理过的事件
                    SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                    m_relation_events.Remove(relation_evt.event_idx);
                    break;
                }

                case eRelationEvent.Agree:    //对方同意了你的申请
                {
                    if (relation_evt.bin_content.bin_agree_content.cmd == eRelationApplyCmd.Agree)
                    {
                        //如果对方在线,则取对方身上的数据;否则取数据库的数据
                        Unit target_player = UnitManager.Instance.GetUnitByIdx(relation_evt.source_char_idx);
                        if (target_player != null)
                        {
                            this.RemoveRelation(relation_evt.source_char_idx);

                            RelationInfo relation_info = CommonObjectPools.Spawn <RelationInfo>();
                            relation_info.Copy(target_player.player_data);
                            relation_info.flags = relation_evt.bin_content.bin_agree_content.flag;
                            this.AddRelation(relation_info);
                            this.SyncRelation2SS(relation_evt.source_char_idx);

                            //清除处理过的事件
                            SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                            m_relation_events.Remove(relation_evt.event_idx);
                        }
                        else
                        {
                            PlayerInfoForGL data = CommonObjectPools.Spawn <PlayerInfoForGL>();
                            SQLCharHandle.QueryCharacterInfo(relation_evt.source_char_idx, data, (ret) =>
                                {
                                    if (ret && m_char_idx > 0)
                                    {
                                        this.RemoveRelation(relation_evt.source_char_idx);

                                        RelationInfo relation_info = CommonObjectPools.Spawn <RelationInfo>();
                                        relation_info.Copy(data);
                                        relation_info.flags = relation_evt.bin_content.bin_agree_content.flag;
                                        this.AddRelation(relation_info);
                                        this.SyncRelation2SS(relation_evt.source_char_idx);
                                    }
                                    CommonObjectPools.Despawn(data);

                                    //清除处理过的事件
                                    SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                                    m_relation_events.Remove(relation_evt.event_idx);
                                });
                        }
                    }
                    else
                    {
                        //清除处理过的事件
                        SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                        m_relation_events.Remove(relation_evt.event_idx);
                    }

                    break;
                }

                case eRelationEvent.Give:
                {
                    Log.Info("赠送 src:" + relation_evt.source_char_idx + " dst:" + relation_evt.target_char_idx);
                    RelationEventContent.GiveContent give_info = relation_evt.bin_content.bin_give_content;
                    //发给ss处理
                    if (item.IsValidItem(give_info.item_id))
                    {
                        gl2ss.RelationGive msg_give = PacketPools.Get(gl2ss.msg.RELATION_GIVE) as gl2ss.RelationGive;
                        msg_give.char_idx = m_char_idx;
                        msg_give.src_player_id.Set(relation_evt.source_char_idx, give_info.char_name);
                        msg_give.item_id = give_info.item_id;
                        ForServerNetManager.Instance.Send(player.ss_srv_uid, msg_give);
                    }

                    //清除处理过的事件
                    SQLRelationHandle.RemoveRelationEvent(relation_evt.event_idx);
                    m_relation_events.Remove(relation_evt.event_idx);
                    break;
                }
                }
            }
        }
コード例 #21
0
 /// <summary>
 /// 加速检测
 /// </summary>
 public static void SendSpeedCheck(int check_sn)
 {
     c2gs.SpeedCheck msg = PacketPools.Get(c2gs.msg.SPEED_CHECK) as c2gs.SpeedCheck;
     msg.check_sn = check_sn;
     ClientNetManager.Instance.Send(msg);
 }
コード例 #22
0
 /// <summary>
 /// 读邮件
 /// </summary>
 public static void SendReadMail(long mail_idx)
 {
     c2ss.MailRead msg = PacketPools.Get(c2ss.msg.MAIL_READ) as c2ss.MailRead;
     msg.mail_idx = mail_idx;
     ClientNetManager.Instance.Send(msg);
 }
コード例 #23
0
        /// <summary>
        /// 处理客户端发送的聊天信息
        /// </summary>
        public void HandleSendChat(Player player, eChatType type, CharacterIdxOrName receiver, string content)
        {
            //TODO:是否禁言

            switch (type)
            {
            case eChatType.PRIVATE:    //私聊
                Player target = null;
                if (receiver.IsIdxValid())
                {
                    // 不能对自己发送
                    if (receiver.char_idx == player.char_idx)
                    {
                        return;
                    }
                    target = UnitManager.Instance.GetPlayerByIdx(receiver.char_idx);
                }
                else
                {
                    if (receiver.char_name == player.char_name)
                    {
                        return;
                    }
                    target = UnitManager.Instance.GetPlayerByName(receiver.char_name);
                }

                if (target != null)
                {    //如果本服玩家在线,直接发送
                    //检测是否在对方黑名单
                    if (RelationManager.Instance.HaveRelationFlag(player.char_idx, target.char_idx, eRelationFlag.Block))
                    {
                        ss2c.ChatResult msg = PacketPools.Get(ss2c.msg.CHAT_RESULT) as ss2c.ChatResult;
                        msg.error = eChatError.ERROR_DST_REFUSE;
                        ServerNetManager.Instance.SendProxy(target.client_uid, msg);
                    }
                    else
                    {
                        //直接发给对方
                        ss2c.ChatRecv msg = PacketPools.Get(ss2c.msg.CHAT_RECV) as ss2c.ChatRecv;
                        msg.type = type;
                        msg.sender.Set(player.char_idx, player.char_name);
                        msg.chat_content = content;
                        ServerNetManager.Instance.SendProxy(player.client_uid, msg);
                    }
                }
                else
                {    //通过ws转发
                    ss2ws.ChatSend msg = PacketPools.Get(ss2ws.msg.CHAT_SEND) as ss2ws.ChatSend;
                    msg.type = type;
                    msg.sender.Set(player.char_idx, player.char_name);
                    msg.receiver     = receiver;
                    msg.chat_content = content;
                    ServerNetManager.Instance.Send2WS(msg);
                }

                break;

            case eChatType.WORLD:    //世界聊天
            {
                ss2c.ChatRecv msg = PacketPools.Get(ss2c.msg.CHAT_RECV) as ss2c.ChatRecv;
                msg.type = type;
                msg.sender.Set(player.char_idx, player.char_name);
                msg.chat_content = content;
                ServerNetManager.Instance.BroadcastProxyMsg(msg);
            }
            break;

            case eChatType.CURRENT:    //当前聊天

                break;

            case eChatType.GROUP:    //组队聊天

                break;

            case eChatType.GUILD:    //军团聊天

                break;

            case eChatType.INSTANCE:    //战场聊天

                break;
            }
        }
コード例 #24
0
 /// <summary>
 /// 请求列表
 /// </summary>
 public static void SendRelationList()
 {
     c2ss.RelationList msg = PacketPools.Get(c2ss.msg.RELATION_LIST) as c2ss.RelationList;
     ClientNetManager.Instance.Send(msg);
 }
コード例 #25
0
 /// <summary>
 /// 请求邮件列表
 /// </summary>
 public static void SendMailList()
 {
     c2ss.MailList msg = PacketPools.Get(c2ss.msg.MAIL_LIST) as c2ss.MailList;
     ClientNetManager.Instance.Send(msg);
 }
コード例 #26
0
        /// <summary>
        /// 投递邮件到信箱
        /// </summary>
        private void OnLoadMailEnd(List <MailInfo> list)
        {
            if (list.Count == 0)
            {
                return;
            }

            //可能读取db时,玩家下线了
            Player player = UnitManager.Instance.GetUnitByIdx(m_char_idx) as Player;

            if (player == null)
            {
                list.ForEach(info => CommonObjectPools.Despawn(info));
                return;
            }

            //过滤掉已经领取过附件的全局邮件
            for (int i = list.Count - 1; i >= 0; --i)
            {
                MailInfo mail_info = list[i];
                if (mail_info.receiver_idx == 0 && m_had_recv_mails.Contains(mail_info.mail_idx))
                {
                    CommonObjectPools.Despawn(mail_info);
                    list.RemoveAt(i);
                }
            }

            //添加到邮件集合
            list.ForEach(info => { if (!m_all_mails.ContainsKey(info.mail_idx))
                                   {
                                       m_all_mails.Add(info.mail_idx, info);
                                   }
                         });

            //加入到新邮件列表
            list.ForEach(info => m_new_mails.Add(info.mail_idx));

            //过滤掉系统内部邮件
            List <long> del_list = new List <long>();

            for (int i = list.Count - 1; i >= 0; i--)
            {
                MailInfo mail_info = list[i];
                if (mail_info.mail_type == eMailType.SYSTEM_INTERNAL)
                {
                    if (mail_info.bin_mail_content.content_type == eMailContentType.MOD)
                    {//修改玩家属性
                        MailModContent content = mail_info.bin_mail_content.bin_mod_content;
                        foreach (var obj in content.mods)
                        {
                            player.player_attr.SetAttrib(obj.type, obj.value_i, obj.value_str);
                        }
                        list.RemoveAt(i);
                        del_list.Add(mail_info.mail_idx);
                    }
                }
            }
            if (del_list.Count > 0)
            {
                this.HandleDeleteMail(del_list);
            }

            //通知客户端有新邮件到达
            if (list.Count > 0)
            {
                //获取未读邮件数量
                int unread_count = 0;
                list.ForEach(info => { if (!Utils.HasFlag(info.flags, (uint)eMailFlags.READED))
                                       {
                                           unread_count++;
                                       }
                             });

                ss2c.MailCount msg = PacketPools.Get(ss2c.msg.MAIL_COUNT) as ss2c.MailCount;
                msg.total_mail_count  = (ushort)list.Count;
                msg.unread_mail_count = (ushort)unread_count;
                ServerNetManager.Instance.SendProxy(player.client_uid, msg);
            }
        }
コード例 #27
0
        /// <summary>
        /// 进入场景
        /// </summary>
        private void OnEnterScene(PacketBase packet)
        {
            c2ss.EnterScene msg    = packet as c2ss.EnterScene;
            Player          player = UnitManager.Instance.GetPlayerByClientUID(msg.client_uid);

            if (player == null)
            {
                Log.Debug("OnEnterScene 未找到unit:" + msg.client_uid.srv_uid + ", " + msg.client_uid.conn_idx);
                return;
            }

            uint scene_idx = 0;

            if (msg.scene_type == 0)
            {                                      //进入游戏后的第一个消息:告诉client需要进入的场景id
                scene_idx = player.scene_type_idx; //上次所在场景
            }
            else
            {
                //相同场景跳转,直接返回
                if (msg.scene_type == player.scene_type_idx)
                {
                    return;
                }
                scene_idx = msg.scene_type;
            }
            //判断场景是否有效
            if (!SceneID.IsValidScene(scene_idx))
            {
                return;
            }

            //加入场景
            BaseScene scene = SceneManager.Instance.CreateScene(scene_idx);

            if (scene != null)
            {
                //先从旧的场景移除
                BaseScene old_scene = SceneManager.Instance.GetScene(player.scene_obj_idx);
                if (old_scene != null)
                {
                    old_scene.RemoveUnit(player);
                }
                //再加入新的场景
                scene.AddUnit(player);
                player.unit_attr.SetAttribInteger(eUnitModType.UMT_scene_type, scene_idx);
            }
            else
            {
                Log.Warning("加入场景失败:" + scene_idx);
                return;
            }

            //告诉client
            ss2c.EnterScene rep_msg = PacketPools.Get(ss2c.msg.ENTER_SCENE) as ss2c.EnterScene;
            rep_msg.scene_type        = scene_idx;
            rep_msg.scene_instance_id = 1;
            rep_msg.pos.Set(player.pos_x, player.pos_y);//TODO:获取场景出生点
            rep_msg.dir = eDirection.NONE;
            ServerNetManager.Instance.SendProxy(msg.client_uid, rep_msg, false);
        }
コード例 #28
0
        private void OnMessageReveived(long conn_idx, ushort header, ByteArray data)
        {
            PacketBase packet = PacketPools.Get(header);

            packet.Read(data);
            do
            {
                ConnAppProc app_server = null;
                if (!m_app_servers.TryGetValue(conn_idx, out app_server))
                {
                    if (packet.header == inner.msg.REQ_LOGIN)
                    {
                        if (!m_app_servers.ContainsKey(conn_idx))
                        {
                            inner.ReqLogin msg = packet as inner.ReqLogin;

                            //检测是否相同id的服务器以及连接
                            if (m_srv_servers.ContainsKey(msg.srv_info.srv_uid))
                            {
                                Log.Warning("相同服务器以及连接 sid:" + msg.srv_info.srv_uid);
                                m_net_socket.CloseConn(conn_idx);
                                break;
                            }
                            Log.Info("收到内部服务器连接请求:" + msg.srv_info.srv_type);
                            //创建新连接
                            app_server                            = CreateConnApp(msg.srv_info.srv_type);
                            app_server.conn_idx                   = conn_idx;
                            app_server.srv_info.srv_type          = msg.srv_info.srv_type;
                            app_server.srv_info.srv_status        = eConnAppStatus.CONNECTED;
                            app_server.srv_info.srv_realm_idx     = ServerConfig.net_info.server_realm;
                            app_server.srv_info.srv_uid           = msg.srv_info.srv_uid;
                            app_server.srv_info.srv_endpoint.ip   = msg.srv_info.srv_endpoint.ip;
                            app_server.srv_info.srv_endpoint.port = msg.srv_info.srv_endpoint.port;
                            m_app_servers.Add(conn_idx, app_server);
                            OnConnAppEnter(app_server);

                            //响应
                            inner.RepLogin rep_msg = PacketPools.Get(inner.msg.REP_LOGIN) as inner.RepLogin;
                            rep_msg.result                 = inner.RepLogin.eResult.SUCCESS;
                            rep_msg.srv_info.srv_type      = eServerType.WORLD;
                            rep_msg.srv_info.srv_realm_idx = ServerConfig.net_info.server_realm;
                            rep_msg.srv_info.srv_uid       = ServerConfig.net_info.server_uid;
                            rep_msg.ws_time                = GameTimeManager.Instance.server_time;
                            this.Send(conn_idx, rep_msg);

                            //告诉启动次数
                            IdSharedManager.Instance.SendStartCount(conn_idx);

                            //告诉当前存在的服务器
                            List <ConnAppProc> list_app = new List <ConnAppProc>();
                            GetConnAppList(list_app, eServerType.GATE);
                            GetConnAppList(list_app, eServerType.SERVER);
                            GetConnAppList(list_app, eServerType.FIGHT);

                            //发送当前存在的服务器列表
                            while (list_app.Count > 0)
                            {
                                inner.AppServerList list_msg = PacketPools.Get(inner.msg.APPSERVER_LIST) as inner.AppServerList;
                                for (int i = 0; i < 10 && list_app.Count > 0; ++i)
                                {
                                    ConnAppProc tmp_app = list_app[list_app.Count - 1];
                                    if (tmp_app.srv_info.srv_uid == app_server.srv_info.srv_uid)
                                    {//不发送自己
                                        list_app.RemoveAt(list_app.Count - 1);
                                        continue;
                                    }

                                    AppServerItem item = new AppServerItem();
                                    item.srv_uid  = tmp_app.srv_info.srv_uid;
                                    item.srv_type = tmp_app.srv_info.srv_type;
                                    item.srv_ip   = tmp_app.srv_info.srv_endpoint.ip;
                                    item.srv_port = tmp_app.srv_info.srv_endpoint.port;
                                    list_msg.list.Add(item);

                                    list_app.RemoveAt(list_app.Count - 1);
                                }
                                if (list_msg.list.Count > 0)
                                {
                                    app_server.Send(list_msg);
                                }
                                else
                                {
                                    PacketPools.Recover(list_msg);
                                }
                            }

                            //广播新服务器加入
                            inner.AppServerAdd add_msg = PacketPools.Get(inner.msg.APPSERVER_ADD) as inner.AppServerAdd;
                            add_msg.app_info.srv_uid  = app_server.srv_info.srv_uid;
                            add_msg.app_info.srv_type = app_server.srv_info.srv_type;
                            add_msg.app_info.srv_ip   = app_server.srv_info.srv_endpoint.ip;
                            add_msg.app_info.srv_port = app_server.srv_info.srv_endpoint.port;
                            this.BroadcastMsgWithout(add_msg, app_server.conn_idx);
                        }
                    }
                }
                if (app_server != null)
                {
                    if (!app_server.HandleMsg(conn_idx, packet))
                    {
                        switch (packet.header)
                        {
                        case inner.msg.APPSERVER_SHUTDOWN:
                            break;
                        }
                    }
                }
            } while (false);
            PacketPools.Recover(packet);
        }
コード例 #29
0
        private void OnMessageReveived(long conn_idx, ushort header, ByteArray data)
        {
            PacketBase packet = PacketPools.Get(header);

            packet.Read(data);

            ConnAppProc app_server;

            if (m_app_servers.TryGetValue(conn_idx, out app_server))
            {
                if (app_server.srv_info.srv_status == eConnAppStatus.CONNECTED)
                {
                    if (!app_server.HandleMsg(conn_idx, packet))
                    {
                        if (app_server.srv_info.srv_type == eServerType.WORLD)
                        {
                            switch (packet.header)
                            {
                            case inner.msg.APPSERVER_LIST:
                                (app_server as WorldMsgProc).HandleAppServerList(packet);
                                break;

                            case inner.msg.APPSERVER_ADD:
                                (app_server as WorldMsgProc).HandleAppServerAdd(packet);
                                break;

                            case inner.msg.APPSERVER_REMOVE:
                                (app_server as WorldMsgProc).HandleAppServerRemove(packet);
                                break;

                            case inner.msg.APPSERVER_SHUTDOWN:
                                Master.Instance.Stop();
                                break;
                            }
                        }
                    }
                }
                else if (app_server.srv_info.srv_status == eConnAppStatus.CONNECTING)
                {
                    if (packet.header == inner.msg.REP_LOGIN)
                    {
                        inner.RepLogin msg = packet as inner.RepLogin;
                        if (msg.result == inner.RepLogin.eResult.SUCCESS)
                        {
                            app_server.srv_info.srv_status = eConnAppStatus.CONNECTED;
                            if (msg.srv_info.srv_type == eServerType.WORLD)
                            {
                                m_srv_realm_idx                   = msg.srv_info.srv_realm_idx;//由世界服分配的id
                                app_server.srv_info.srv_uid       = msg.srv_info.srv_uid;
                                app_server.srv_info.srv_realm_idx = msg.srv_info.srv_realm_idx;
                                GameTimeManager.Instance.SetAdjustTime(msg.ws_time - Time.time);//修正服务器时间
                                Log.Info("当前时间:" + Time.time + " 当前ws时间:" + msg.ws_time);
                                Log.Info("当前服所属区服id:" + m_srv_realm_idx + ", sid:" + m_srv_uid);
                            }
                            OnConnAppEnter(app_server);
                        }
                        else
                        {
                            Log.Warning("连接服务器出错 type:" + msg.srv_info.srv_type + " result:" + msg.result);
                        }
                    }
                    else
                    {
                        Log.Warning("收到无效协议:" + packet.header);
                    }
                }
            }
            PacketPools.Recover(packet);
        }
コード例 #30
0
 /// <summary>
 /// 写邮件
 /// </summary>
 public static void SendWriteMail(MailWriteInfo info)
 {
     c2ss.MailWrite msg = PacketPools.Get(c2ss.msg.MAIL_WRITE) as c2ss.MailWrite;
     msg.info = info;
     ClientNetManager.Instance.Send(msg);
 }