Esempio n. 1
0
        protected virtual void PublishLeaveEvent(Actor actor, LeaveRequest leaveRequest)
        {
            if (SuppressRoomEvents)
            {
                return;
            }

            if (Actors.Count > 0 && actor != null)
            {
                var actorNumbers = Actors.GetActorNumbers();
                var leaveEvent   = new LeaveEvent(actor.ActorNr, actorNumbers.ToArray());
                PublishEvent(leaveEvent, Actors, new SendParameters());
            }
        }
Esempio n. 2
0
        protected virtual void PublishJoinEvent(PlayerPeer peer, JoinRequest joinRequest)
        {
            if (SuppressRoomEvents)
            {
                return;
            }

            var actor = GetActorByPeer(peer);

            if (actor == null)
            {
                return;
            }

            // generate a join event and publish to all actors in the room
            var joinEvent = new JoinEvent(actor.ActorNr, Actors.GetActorNumbers().ToArray());

            if (joinRequest.BroadcastActorProperties)
            {
                joinEvent.ActorProperties = joinRequest.ActorProperties;
            }

            PublishEvent(joinEvent, Actors, new SendParameters());
        }
Esempio n. 3
0
        protected virtual void HandleRaiseEventOperation(
            PlayerPeer peer,
            RaiseEventRequest raiseEventRequest,
            SendParameters sendParameters)
        {
            // get the actor who send the operation request
            var actor = GetActorByPeer(peer);

            if (actor == null)
            {
                return;
            }

            sendParameters.Flush = raiseEventRequest.Flush;

            if (raiseEventRequest.Cache == (byte)CacheOperation.RemoveFromRoomCache)
            {
                EventCache.RemoveEvents(raiseEventRequest);
                var response =
                    new OperationResponse(raiseEventRequest.OperationRequest.OperationCode)
                {
                    ReturnCode = 0
                };
                peer.SendOperationResponse(response, sendParameters);
                return;
            }

            if (raiseEventRequest.Cache == (byte)CacheOperation.RemoveFromCacheForActorsLeft)
            {
                var currentActorNumbers = Actors.GetActorNumbers();
                EventCache.RemoveEventsForActorsNotInList(currentActorNumbers);
                var response =
                    new OperationResponse(raiseEventRequest.OperationRequest.OperationCode)
                {
                    ReturnCode = 0
                };
                peer.SendOperationResponse(response, sendParameters);
                return;
            }

            // publish the custom event
            var customEvent = new CustomEvent(actor.ActorNr, raiseEventRequest.EvCode, raiseEventRequest.Data);

            var updateEventCache = false;
            IEnumerable <Actor> recipients;

            if (raiseEventRequest.Actors != null && raiseEventRequest.Actors.Length > 0)
            {
                recipients = Actors.GetActorsByNumbers(raiseEventRequest.Actors);
            }
            else if (raiseEventRequest.Group != 0)
            {
                ActorGroup group;
                if (ActorGroups.TryGetValue(raiseEventRequest.Group, out group))
                {
                    recipients = group.GetExcludedList(actor);
                }
                else
                {
                    return;
                }
            }
            else
            {
                switch ((ReceiverGroup)raiseEventRequest.ReceiverGroup)
                {
                case ReceiverGroup.All:
                    recipients       = Actors;
                    updateEventCache = true;
                    break;

                case ReceiverGroup.Others:
                    recipients       = Actors.GetExcludedList(actor);
                    updateEventCache = true;
                    break;

                case ReceiverGroup.MasterClient:
                    recipients = new[] { Actors[0] };
                    break;

                default:
                    peer.SendOperationResponse(
                        new OperationResponse
                    {
                        OperationCode = raiseEventRequest.OperationRequest.OperationCode,
                        ReturnCode    = -1,
                        DebugMessage  =
                            "Invalid ReceiverGroup " + raiseEventRequest.ReceiverGroup
                    },
                        sendParameters);
                    return;
                }
            }

            if (updateEventCache && raiseEventRequest.Cache != (byte)CacheOperation.DoNotCache)
            {
                string msg;
                if (!UpdateEventCache(actor, raiseEventRequest, out msg))
                {
                    peer.SendOperationResponse(
                        new OperationResponse
                    {
                        OperationCode = raiseEventRequest.OperationRequest.OperationCode,
                        ReturnCode    = -1,
                        DebugMessage  = msg
                    },
                        sendParameters);
                    return;
                }
            }

            PublishEvent(customEvent, recipients, sendParameters);
        }