Example #1
0
        private void OnChangeUserState(DecodeBstResult bst, string seq)
        {
            Debugger.Log("onChangeUserState bst: {0}", seq);
            var eve = new BroadcastEvent(bst.Body, seq);

            this.responses.OnChangeCustomPlayerStatus(eve);
        }
Example #2
0
        private void OnChangePlayerNetworkState(DecodeBstResult bst, string seq)
        {
            // Debugger.Log("onChangePlayerNetworkState bst: {0}", seq);
            var eve = new BroadcastEvent(bst.Body, seq);

            this.responses.OnChangePlayerNetworkState(eve);
        }
Example #3
0
        private void OnChangeRoom(DecodeBstResult bst, string seq)
        {
            Debugger.Log("onChangeRoom bst: {0}", seq);
            var eve = new BroadcastEvent(bst.Body, seq);

            this.responses.OnChangeRoom(eve);
        }
Example #4
0
        private void OnRemoveUser(DecodeBstResult bst, string seq)
        {
            Debugger.Log("onRemoveUser bst: {0}", seq);
            var eve = new BroadcastEvent(bst.Body, seq);

            this.responses.OnRemovePlayer(eve);
        }
Example #5
0
        // 队组内玩家网络状态变化广播
        public void OnChangeGroupPlayerNetworkState(BroadcastEvent eve)
        {
            var bst         = (ChangePlayerNetworkStateBst)eve.Data;
            var groupIdList = bst.GroupIdList;
            var groupId     = (this._group?.GroupInfo?.Id) + "";

            if (groupId.Length <= 0)
            {
                return;
            }

            if (groupIdList.Count <= 0)
            {
                return;
            }

            if (!groupIdList.Contains(groupId))
            {
                return;
            }

            if (bst.NetworkState == NetworkState.RelayOffline || bst.NetworkState == NetworkState.RelayOnline)
            {
                return;
            }

            // 更新队组信息
            this._group?.GroupUtil?.TriggerNetWorkBroadcast(bst, eve.Seq);
        }
Example #6
0
        /// <summary>
        /// 握手成功手的连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="me"></param>
        private void Ci_NewUserConnection(object sender, MessageEntity me)
        {
            ClientSocketInstance ci = sender as ClientSocketInstance;

            BroadcastMessage += new BroadcastEvent(ci.SendMessage);
            callback.NewUserConnectionJoin(ci, me);
        }
Example #7
0
        private void CancelMatchBroadcast(DecodeBstResult bst, string seq)
        {
            var eve = new BroadcastEvent(bst.Body, seq);

            Debugger.Log("CancelMatchBroadcast {0}", eve);
            this.bstCallbacks.Room.OnCancelMatch(eve);
        }
Example #8
0
        // 开始游戏
        private void OnStartFrameSync(DecodeBstResult res, string seq)
        {
            var eve = new BroadcastEvent(res.Body, seq);

            FrameBst.Clear();
            this._responses.OnStartFrameSync(eve);
        }
Example #9
0
        /**
         * 玩家修改房间广播
         */
        public void OnChangeRoom(BroadcastEvent eve)
        {
            var roomInfo = ((ChangeRoomBst)eve.Data).RoomInfo;

            this.Save(eve, roomInfo);
            _room.OnChangeRoom?.Invoke(eve);
        }
Example #10
0
        private void OnChangeRoom(DecodeBstResult bst, string seq)
        {
            var eve = new BroadcastEvent(bst.Body, seq);

            Debugger.Log("OnChangeRoom {0}", eve);
            this.bstCallbacks.Room.OnChangeRoom(eve);
        }
Example #11
0
        /**
         * 玩家修改玩家状态广播
         */
        public void OnChangeCustomPlayerStatus(BroadcastEvent eve)
        {
            var roomInfo = ((ChangeCustomPlayerStatusBst)eve.Data).RoomInfo;

            this.Save(eve, roomInfo);
            _room.OnChangeCustomPlayerStatus?.Invoke(eve);
        }
Example #12
0
        /**
         * 开始游戏广播
         */
        public void OnStartFrameSync(BroadcastEvent eve)
        {
            var roomInfo = ((StartFrameSyncBst)eve.Data).RoomInfo;

            this.Save(eve, roomInfo);
            _room.OnStartFrameSync?.Invoke(eve);
        }
        private void Broadcast(BroadcastEvent @event)
        {
            if (RuiJiConfiguration.Standalone)
            {
                FeedScheduler.Schedulers.First().Value.OnReceive(@event);
            }
            else
            {
                var node = ServerManager.Get(Request.Host.Value) as NodeBase;
                var nv   = node.GetChildren("/live_nodes/feed");

                foreach (string path in nv.Keys)
                {
                    var baseUrl = path.Substring(path.LastIndexOf("/") + 1);

                    var client      = new RestClient("http://" + baseUrl);
                    var restRequest = new RestRequest("api/feed/change");
                    restRequest.Method         = Method.POST;
                    restRequest.JsonSerializer = new NewtonJsonSerializer();
                    restRequest.AddJsonBody(@event);

                    restRequest.Timeout = 15000;

                    client.ExecuteAsync(restRequest, (restResponse) => { });
                }
            }
        }
Example #14
0
        /**
         * 玩家网络状态变化广播
         */
        public void OnChangePlayerNetworkState(BroadcastEvent eve)
        {
            var roomInfo = ((ChangePlayerNetworkStateBst)eve.Data).RoomInfo;

            this.Save(eve, roomInfo);
            _room.OnChangePlayerNetworkState?.Invoke(eve);
        }
        public bool ChangeFeedStatus(string ids, string status)
        {
            var changeIds  = ids.Split(',').Select(i => Convert.ToInt32(i)).ToArray();
            var statusEnum = (Status)Enum.Parse(typeof(Status), status.ToUpper());

            if (statusEnum == Status.ON)
            {
                var feeds = FeedLiteDb.GetFeed(changeIds);

                foreach (var feed in feeds)
                {
                    var @event = new BroadcastEvent()
                    {
                        Event = BroadcastEventEnum.UPDATE,
                        Args  = feed
                    };

                    Broadcast(@event);
                }
            }
            else
            {
                var @event = new BroadcastEvent()
                {
                    Event = BroadcastEventEnum.REMOVE,
                    Args  = changeIds
                };

                Broadcast(@event);
            }

            return(FeedLiteDb.ChangeStatus(changeIds, statusEnum));
        }
Example #16
0
        private void MatchUsersBroadcast(DecodeBstResult bst, string seq)
        {
            var eve = new BroadcastEvent(bst.Body, seq);

            Debugger.Log("MatchUsersBroadcast {0}", eve);
            this.bstCallbacks.Room.OnMatchPlayers(eve);
        }
Example #17
0
        // 结束游戏
        private void OnStopFrameSync(DecodeBstResult bst, string seq)
        {
            var eve = new BroadcastEvent(bst.Body, seq);

            NetUtil2?.client.ClearQueue();
            FrameBst.Clear();
            this._responses.OnStopFrameSync(eve);
        }
Example #18
0
        /**
         * 结束游戏广播
         */
        public void OnStopFrameSync(BroadcastEvent eve)
        {
            this.FrameBroadcast.Reset(0);
            var roomInfo = ((StopFrameSyncBst)eve.Data).RoomInfo;

            this.Save(eve, roomInfo);
            _room.OnStopFrameSync?.Invoke(eve);
        }
Example #19
0
        // 自定义服务广播
        private void OnRecvFromGameSvr(DecodeBstResult bst, string seq)
        {
            var body = (RecvFromGameSvrBst)bst.Body;
            var eve  = new BroadcastEvent(bst.Body, seq);

            Debugger.Log("OnRecvFromGameSvr {0}", eve);
            this._bstCallbacks.Room.OnRecvFromGameSvr(body.RoomId, eve);
        }
Example #20
0
        // 开始游戏
        private void OnStartFrameSync(DecodeBstResult res, string seq)
        {
            var eve = new BroadcastEvent(res.Body, seq);

            Debugger.Log("OnStartFrameSync {0}", eve);
            FrameBst.Clear();
            this._bstCallbacks.Room.OnStartFrameSync(eve);
        }
Example #21
0
        /// <summary>
        /// Registers a plugin with the broadcaster.
        /// </summary>
        public Broadcaster RegisterPlugin(string name, string version, BroadcastEvent handler)
        {
            Broadcaster broadcaster = new Broadcaster (name, version, handler);
            broadcasters.Add (broadcaster);

            return broadcaster;
        }
Example #22
0
 public Broadcaster(string name, string version, BroadcastEvent handler)
 {
     this.name = name;
     this.version = version;
     this.handler = handler;
 }
Example #23
0
 /// <summary>
 /// 握手成功手的连接
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="me"></param>
 private void Ci_NewUserConnection(object sender, MessageEntity me)
 {
     ClientSocketInstance ci = sender as ClientSocketInstance;
     BroadcastMessage += new BroadcastEvent(ci.SendMessage);
     callback.NewUserConnectionJoin(ci, me);
 }