Exemplo n.º 1
0
 /// <summary>
 /// Handles the execution of an incoming event.
 /// </summary>
 private void ProcessEvent(RailEvent evnt)
 {
     if (this.EventReceived != null)
     {
         this.EventReceived.Invoke(evnt, this);
     }
     this.processedEventHistory =
         this.processedEventHistory.Store(evnt.EventId);
 }
Exemplo n.º 2
0
        /// <summary>
        /// Selects outgoing events to send.
        /// </summary>
        private IEnumerable <RailEvent> FilterOutgoingEvents()
        {
            // The receiving client can only store SequenceWindow.HISTORY_LENGTH
            // events in its received buffer, and will skip any events older than
            // its latest received minus that history length, including reliable
            // events. In order to make sure we don't force the client to skip a
            // reliable event, we will throttle the outgoing events if we've been
            // sending them too fast. For example, if we have a reliable event
            // with ID 3 pending, the highest ID we can send would be ID 67. If we
            // send an event with ID 68, then the client may ignore ID 3 when it
            // comes in for being too old, even though it's reliable.
            //
            // In practice this shouldn't be a problem unless we're sending way
            // more events than is reasonable(/possible) in a single packet, or
            // something is wrong with reliable event acking.

            SequenceId firstReliable = SequenceId.INVALID;

            foreach (RailEvent evnt in this.outgoingEvents)
            {
                if (evnt.IsReliable)
                {
                    if (firstReliable.IsValid == false)
                    {
                        firstReliable = evnt.EventId;
                    }
                    RailDebug.Assert(firstReliable <= evnt.EventId);
                }

                if (firstReliable.IsValid)
                {
                    if (SequenceWindow.AreInRange(firstReliable, evnt.EventId) == false)
                    {
                        string current = "Throttling events due to unacked reliable\n";
                        foreach (RailEvent evnt2 in this.outgoingEvents)
                        {
                            current += evnt2.EventId + " ";
                        }
                        RailDebug.LogWarning(current);
                        break;
                    }
                }

                if (evnt.CanSend)
                {
                    yield return(evnt);
                }
            }
        }
Exemplo n.º 3
0
        protected RailPeer(
            IRailNetPeer netPeer,
            RailInterpreter interpreter,
            RailPacket reusableIncoming,
            RailPacket reusableOutgoing)
        {
            this.netPeer     = netPeer;
            this.interpreter = interpreter;

            this.controlledEntities = new HashSet <RailEntity>();
            this.remoteClock        = new RailClock();

            this.outgoingEvents        = new Queue <RailEvent>();
            this.reusableIncoming      = reusableIncoming;
            this.reusableOutgoing      = reusableOutgoing;
            this.lastQueuedEventId     = SequenceId.START.Next;
            this.processedEventHistory = new SequenceWindow(SequenceId.START);

            this.netPeer.PayloadReceived += this.OnPayloadReceived;
        }