[chaz/carfire] / Project06 / CS 3505 Project 06 / CS 3505 Project 06 / NetworkGame.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Net;
using System.Diagnostics;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using System.Collections;

namespace CS_3505_Project_06
{
    /// <summary>
    /// A manager class to handle network interactions between peers and
    /// lobby/game switching.
    /// </summary>
    public class NetworkGame
    {
        // Public methods and properties
        #region Public Methods

        /// <summary>
        /// Called when a session has been created or joined using CreateSession() or JoinSession().
        /// </summary>
        /// <param name="session">The new session that was created or joined.</param>
        /// <param name="networkGame">The NetworkGame that joined the session.</param>
        public delegate void JoinedSessionDelegate(NetworkSession session, NetworkGame networkGame);

        /// <summary>
        /// Called when sessions are found as a result of calling FindSessions().
        /// </summary>
        /// <param name="sessions">A container of the available sessions.</param>
        /// <param name="networkGame">The NetworkGame that searched for the sessions.</param>
        public delegate void FoundSessionsDelegate(AvailableNetworkSessionCollection sessions, NetworkGame networkGame);


        /// <summary>
        /// Construct a NetworkGame with a lobby and a game.
        /// </summary>
        /// <param name="lobby">Provides an associated lobby to update and draw.</param>
        /// <param name="game">Provides a game object to be played over the network.</param>
        public NetworkGame(ILobby lobby, IDeterministicGame game)
        {
            Debug.Assert(lobby != null && game != null);

            mLobby = lobby;
            mGame = game;
        }


        /// <summary>
        /// Get the Gamer object for the local player.
        /// </summary>
        public LocalNetworkGamer LocalGamer
        {
            get
            {
                // TODO: Is this the correct way to get the single local gamer?
                return mNetworkSession.LocalGamers[0];
            }
        }

        /// <summary>
        /// Get all the gamers associated with the active network session.
        /// </summary>
        public GamerCollection<NetworkGamer> NetworkGamers
        {
            get
            {
                return mNetworkSession.AllGamers;
            }
        }


        /// <summary>
        /// Begin a new network session with the local gamer as the host.  You must not
        /// call this method or use JoinSession without first using LeaveSession.
        /// </summary>
        /// <param name="callback">The delegate/method to call when the session is created.</param>
        public void CreateSession(JoinedSessionDelegate callback)
        {
            CreateSession(mGame.MaximumSupportedPlayers, callback);
        }

        /// <summary>
        /// Begin a new network session with the local gamer as the host.  You must not
        /// call this method or use JoinSession without first using LeaveSession.
        /// </summary>
        /// <param name="maxGamers">Provide the maximum number of players allowed to connect.</param>
        /// <param name="callback">The delegate/method to call when the session is created.</param>
        public void CreateSession(int maxGamers, JoinedSessionDelegate callback)
        {
            Debug.Assert(mNetworkSession == null);

            mJoinedSessionDelegate = callback;
            NetworkSession.BeginCreate(NetworkSessionType.SystemLink, 1, maxGamers, CreateSessionEnd, null);
        }
        private void CreateSessionEnd(IAsyncResult result)
        {
            Debug.Assert(mNetworkSession == null);

            mNetworkSession = NetworkSession.EndCreate(result);
            mNetworkSession.AllowHostMigration = true;
            mNetworkSession.AllowJoinInProgress = false;

            mJoinedSessionDelegate(mNetworkSession, this);
        }

        /// <summary>
        /// Determine whether or not the network game object is associated with any network session.
        /// </summary>
        /// <returns>True if there exists a NetworkSession; false otherwise.</returns>
        public bool HasActiveSession
        {
            get
            {
                return mNetworkSession != null;
            }
        }


        /// <summary>
        /// Find available sessions to join.  You should not already be in a session when
        /// calling this method; call LeaveSession first.
        /// </summary>
        /// <param name="callback">The delegate/method to call when the search finishes.</param>
        public void FindSessions(FoundSessionsDelegate callback)
        {
            Debug.Assert(mNetworkSession == null);

            mFoundSessionsDelegate = callback;
            NetworkSession.BeginFind(NetworkSessionType.SystemLink, 1, null, new AsyncCallback(FindSessionsEnd), null);
        }
        private void FindSessionsEnd(IAsyncResult result)
        {
            AvailableNetworkSessionCollection sessions = NetworkSession.EndFind(result);
            mFoundSessionsDelegate(sessions, this);
        }

        /// <summary>
        /// Join a network session found using FindSessions().  This is for joining a game that
        /// somebody else has already started hosting.  You must not already be in a session.
        /// </summary>
        /// <param name="availableSession">Pass the session object to try to join.</param>
        /// <param name="callback">The delegate/method to call when the search finishes.</param>
        public void JoinSession(AvailableNetworkSession availableSession, JoinedSessionDelegate callback)
        {
            Debug.Assert(mNetworkSession == null);

            mJoinedSessionDelegate = callback;
            NetworkSession.BeginJoin(availableSession, JoinSessionEnd, null);
        }
        private void JoinSessionEnd(IAsyncResult result)
        {
            Debug.Assert(mNetworkSession == null);

            mNetworkSession = NetworkSession.EndJoin(result);

            mJoinedSessionDelegate(mNetworkSession, this);
            mJoinedSessionDelegate = null;
        }


        /// <summary>
        /// Leave and dispose of any currently associated network session.  You will find yourself
        /// back in the lobby.  You must already be in a session to leave it.
        /// </summary>
        public void LeaveSession()
        {
            Debug.Assert(mNetworkSession != null);

            mNetworkSession.Dispose();
            mNetworkSession = null;
        }


        /// <summary>
        /// Set up the network session to simulate 200ms latency and 10% packet loss.
        /// </summary>
        public void SimulateBadNetwork()
        {
            Debug.Assert(mNetworkSession != null);

            mNetworkSession.SimulatedLatency = new TimeSpan(0, 0, 0, 0, 200);
            mNetworkSession.SimulatedPacketLoss = 0.1f;
        }


        /// <summary>
        /// Indicate that the game should begin (moving players from the lobby to the game).
        /// You must call CreateSession() before calling this.
        /// </summary>
        public void StartGame()
        {
            Debug.Assert(mNetworkSession != null && mNetworkSession.IsHost &&
                         mNetworkSession.AllGamers.Count >= mGame.MinimumSupportedPlayers &&
                         mNetworkSession.IsEveryoneReady);

            ForceStartGame();
        }

        /// <summary>
        /// Indicate that the game should begin.  This is like StartGame() without the sanity
        /// checks.  Use this for debugging.
        /// </summary>
        public void ForceStartGame()
        {
            mNetworkSession.StartGame();
            mNetworkSession.ResetReady();

            Reset();
        }


        /// <summary>
        /// Manages the network session and allows either the lobby or game to update.
        /// </summary>
        /// <param name="gameTime">Pass the time away.</param>
        public void Update(GameTime gameTime)
        {
            if (mNetworkSession == null)
            {
                mLobby.Update(gameTime, this);
            }
            else
            {
                mNetworkSession.Update();
                HandleIncomingPackets();

                if (mNetworkSession.SessionState == NetworkSessionState.Lobby)
                {
                    mLobby.Update(gameTime, this);
                }
                else if (mNetworkSession.SessionState == NetworkSessionState.Playing)
                {
                    if (mGame.IsGameOver(LocalGamerInfo) || mGame.IsTerminated(LocalGamerInfo))
                    {
                        // TODO: Should support moving back to the session lobby.
                        LeaveSession();
                        return;
                    }

                    if (HaveNeededEvents)
                    {
                        if (IsLatencyAdjustmentFrame)
                        {
                            AdjustLatency();
                            mStallCount = 0;
                        }
                        mLocalEvents.AddRange(GetEventsFromInput());
                        SendLocalEvents();
                        ApplyEvents();
                        mGame.Update(mTargetTimeSpan);
                    }
                    else // Stall!
                    {
                        mStallCount++;

                        if (mStallCount % 60 == 0)
                        {
                            Console.WriteLine("Stalled for " + mStallCount + " frames.");
                        }

                        /*if (mStallCount > StallTimeout)
                        {
                            DropLostGamers();
                            mStallCount = 0;
                        }
                        else if (mStallCount == 1)
                        {
                            SendLocalEvents
                        }
                        else if (mStallCount % 60 == 0)
                        {
                        } TODO */
                    }
                }
            }
        }

        /// <summary>
        /// Allows either the lobby or the game to draw, depending on the state
        /// of the network connection and whether or not a game is in progress.
        /// </summary>
        /// <param name="gameTime">Pass the time away.</param>
        /// <param name="spriteBatch">The sprite batch.</param>
        public void Draw(GameTime gameTime, SpriteBatch spriteBatch)
        {
            if (mNetworkSession == null)
            {
                mLobby.Draw(spriteBatch);
            }
            else
            {
                if (mNetworkSession.SessionState == NetworkSessionState.Lobby)
                {
                    mLobby.Draw(spriteBatch);
                }
                else if (mNetworkSession.SessionState == NetworkSessionState.Playing)
                {
                    mGame.Draw(spriteBatch);
                }
            }
        }


        /// <summary>
        /// Get the chat messages that have been receive since the last time this
        /// method was called.
        /// </summary>
        /// <returns>List container of the chat messages.</returns>
        public List<ChatInfo> ReceiveChats()
        {
            List<ChatInfo> chats = mChatPackets;
            mChatPackets = new List<ChatInfo>();
            return chats;
        }

        /// <summary>
        /// Send a chat message to all gamers in the session.  You should already be
        /// in a session before calling this method.
        /// </summary>
        /// <param name="message">The text of the message.</param>
        public void SendChat(String message)
        {
            WriteChatPacket(message);
            LocalGamer.SendData(mPacketWriter, SendDataOptions.ReliableInOrder);
        }

        /// <summary>
        /// Send a chat message to a specific gamer in the session.  You should already
        /// be in a session before calling this method.
        /// </summary>
        /// <param name="message">The text of the message.</param>
        /// <param name="recipient">The gamer to receive the message.</param>
        public void SendChat(String message, NetworkGamer recipient)
        {
            WriteChatPacket(message);
            LocalGamer.SendData(mPacketWriter, SendDataOptions.ReliableInOrder, recipient);
        }

        #endregion


        // Private class variable members
        #region Instance Variables

        NetworkSession mNetworkSession;
        PacketReader mPacketReader = new PacketReader();
        PacketWriter mPacketWriter = new PacketWriter();

        JoinedSessionDelegate mJoinedSessionDelegate;
        FoundSessionsDelegate mFoundSessionsDelegate;

        ILobby mLobby;
        IDeterministicGame mGame;

        List<ChatInfo> mChatPackets = new List<ChatInfo>();

        List<EventInfo> mLocalEvents = new List<EventInfo>();
        List<EventInfo> mLastLocalEvents = new List<EventInfo>();

        List<Keys> mLastPressedKeys = new List<Keys>();
        bool mLastLeftButtonPressed;
        bool mLastRightButtonPressed;
        bool mLastMiddleButtonPressed;
        int mLastMousePositionX;
        int mLastMousePositionY;

        int mLatency;
        long mNextLatencyAdjustmentFrame;
        int mStallCount;
        int mAverageOwd;

        TimeSpan mTargetTimeSpan = new TimeSpan(166666);
        public TimeSpan TargetTimeSpan
        {
            get
            {
                return mTargetTimeSpan;
            }
        }

        Dictionary<byte, GamerInfo> mGamers;
        GamerInfo[] GamerArray
        {
            get
            {
                GamerInfo[] gamerList = mGamers.Values.ToArray();
                Array.Sort(gamerList, delegate(GamerInfo a, GamerInfo b)
                {
                    return a.Gamer.Id.CompareTo(b.Gamer.Id);
                });
                return gamerList;
            }
        }
        GamerInfo LocalGamerInfo
        {
            get
            {
                return mGamers[LocalGamer.Id];
            }
        }

        #endregion


        // Private types for the implementation of the network protocol
        #region Private Types
        
        enum PacketType
        {
            Chat = 1,
            Event = 2,
            Stall = 3
        }

        enum EventType
        {
            KeyDown = 1,
            KeyUp = 2,
            MouseDown = 3,
            MouseUp = 4,
            MouseMove = 5
        }

        enum MouseButton
        {
            Left = 1,
            Right = 2,
            Middle = 3
        }

        abstract class EventInfo
        {
            public NetworkGamer Gamer;
            public long FrameOfApplication;

            public EventInfo(NetworkGamer gamer, long frameNumber)
            {
                Gamer = gamer;
                FrameOfApplication = frameNumber;
            }

            public abstract EventType Id
            {
                get;
            }
        }

        class KeyboardEventInfo : EventInfo
        {
            public Keys Key;
            public bool IsKeyDown;

            public KeyboardEventInfo(NetworkGamer gamer, long frameNumber, Keys key, bool isDown)
                : base(gamer, frameNumber)
            {
                Key = key;
                IsKeyDown = isDown;
            }

            public override EventType Id
            {
                get { return IsKeyDown ? EventType.KeyDown : EventType.KeyUp; }
            }
        }

        class MouseButtonEventInfo : EventInfo
        {
            public MouseButton Button;
            public bool IsButtonDown;

            public MouseButtonEventInfo(NetworkGamer gamer, long frameNumber, MouseButton button, bool isDown)
                : base(gamer, frameNumber)
            {
                Button = button;
                IsButtonDown = isDown;
            }

            public override EventType Id
            {
                get { return IsButtonDown ? EventType.MouseDown : EventType.MouseUp; }
            }
        }

        class MouseMotionEventInfo : EventInfo
        {
            public int X;
            public int Y;

            public MouseMotionEventInfo(NetworkGamer gamer, long frameNumber, int x, int y)
                : base(gamer, frameNumber)
            {
                X = x;
                Y = y;
            }

            public override EventType Id
            {
                get { return EventType.MouseMove; }
            }
        }

        class GamerInfo
        {
            public NetworkGamer Gamer;
            public long HighestFrameNumber = 0;
            public int StallCount = 0;
            public int AverageOwd = 0;
            public bool IsWaitedOn = false;
            public List<EventInfo>[] Events = new List<EventInfo>[MaximumLatency];

            public GamerInfo(NetworkGamer gamer)
            {
                Gamer = gamer;
            }
        }

        const int MaximumLatency = 120;
        const int StallTimeout = 900;

        #endregion


        // Private implementation methods of the network protocol
        #region Private Implementation Methods

        /// <summary>
        /// Reinitialize the private variables in preparation for a new game to start.
        /// </summary>
        void Reset()
        {
            mLatency = 1;
            mNextLatencyAdjustmentFrame = 1;
            mStallCount = 0;
            mAverageOwd = CurrentAverageOneWayDelay;

            mGamers = new Dictionary<byte, GamerInfo>();
            foreach (NetworkGamer gamer in NetworkGamers)
            {
                mGamers.Add(gamer.Id, new GamerInfo(gamer));
            }

            mGame.ResetGame(GamerArray, LocalGamerInfo);
        }


        void HandleIncomingPackets()
        {
            LocalNetworkGamer localGamer = LocalGamer;

            while (localGamer.IsDataAvailable)
            {
                NetworkGamer sender;

                localGamer.ReceiveData(mPacketReader, out sender);
                GamerInfo senderInfo = mGamers[sender.Id];

                PacketType packetId = (PacketType)mPacketReader.ReadByte();
                switch (packetId)
                {
                    case PacketType.Chat:

                        short messageLength = mPacketReader.ReadInt16();
                        char[] message = mPacketReader.ReadChars(messageLength);

                        ChatInfo chatPacket = new ChatInfo(sender, new String(message));
                        mChatPackets.Add(chatPacket);
                        break;

                    case PacketType.Event:

                        short stallCount = mPacketReader.ReadInt16();
                        short averageOwd = mPacketReader.ReadInt16();
                        int frameNumber = mPacketReader.ReadInt32();
                        byte numEvents = mPacketReader.ReadByte();

                        if (frameNumber <= senderInfo.HighestFrameNumber)
                        {
                            // we know about all these events, so don't bother reading them
                            break;
                        }

                        for (byte i = 0; i < numEvents; ++i)
                        {
                            EventInfo eventInfo = ReadEvent(mPacketReader, sender);
                            
                            if (eventInfo != null && eventInfo.FrameOfApplication < senderInfo.HighestFrameNumber)
                            {
                                int index = EventArrayIndex;
                                if (senderInfo.Events[index] == null) senderInfo.Events[index] = new List<EventInfo>();
                                senderInfo.Events[index].Add(eventInfo);
                            }
                        }

                        senderInfo.StallCount = stallCount;
                        senderInfo.AverageOwd = averageOwd;
                        senderInfo.HighestFrameNumber = frameNumber;
                        break;

                    case PacketType.Stall:

                        byte numStalledPeers = mPacketReader.ReadByte();
                        byte[] stalledPeers = mPacketReader.ReadBytes(numStalledPeers);

                        // TODO

                        break;

                    default:

                        Console.WriteLine("Received unknown packet type: " + (int)packetId);
                        break;
                }
            }
        }


        int EventArrayIndex
        {
            get { return (int)(mGame.CurrentFrameNumber % MaximumLatency); }
        }

        EventInfo ReadEvent(PacketReader packetReader, NetworkGamer sender)
        {
            EventType eventId = (EventType)packetReader.ReadByte();
            long frameNumber = packetReader.ReadInt32();

            switch (eventId)
            {
                case EventType.KeyDown:

                    int keyCode1 = packetReader.ReadInt32();
                    return new KeyboardEventInfo(sender, frameNumber, (Keys)keyCode1, true);

                case EventType.KeyUp:

                    int keyCode2 = packetReader.ReadInt32();
                    return new KeyboardEventInfo(sender, frameNumber, (Keys)keyCode2, false);

                case EventType.MouseDown:

                    byte buttonId1 = packetReader.ReadByte();
                    return new MouseButtonEventInfo(sender, frameNumber, (MouseButton)buttonId1, true);

                case EventType.MouseUp:

                    byte buttonId2 = packetReader.ReadByte();
                    return new MouseButtonEventInfo(sender, frameNumber, (MouseButton)buttonId2, false);

                case EventType.MouseMove:

                    short x = packetReader.ReadInt16();
                    short y = packetReader.ReadInt16();
                    return new MouseMotionEventInfo(sender, frameNumber, x, y);

                default:

                    Console.WriteLine("Received unknown event type: " + (int)eventId);
                    return null;
            }
        }


        void WriteChatPacket(String message)
        {
            mPacketWriter.Write((byte)PacketType.Chat);
            mPacketWriter.Write((short)message.Length);
            mPacketWriter.Write(message.ToCharArray());
        }

        void WriteEventPacket(List<EventInfo> events)
        {
            mPacketWriter.Write((byte)PacketType.Event);
            mPacketWriter.Write((short)mStallCount);
            mPacketWriter.Write((short)mAverageOwd);
            mPacketWriter.Write((int)(mGame.CurrentFrameNumber + mLatency));
            mPacketWriter.Write((byte)events.Count);

            foreach (EventInfo eventInfo in events)
            {
                mPacketWriter.Write((byte)eventInfo.Id);
                mPacketWriter.Write((int)eventInfo.FrameOfApplication);

                KeyboardEventInfo keyboardEventInfo = eventInfo as KeyboardEventInfo;
                if (keyboardEventInfo != null)
                {
                    mPacketWriter.Write((int)keyboardEventInfo.Key);
                    continue;
                }

                MouseButtonEventInfo mouseButtonEventInfo = eventInfo as MouseButtonEventInfo;
                if (mouseButtonEventInfo != null)
                {
                    mPacketWriter.Write((byte)mouseButtonEventInfo.Button);
                    continue;
                }

                MouseMotionEventInfo mouseMotionEventInfo = eventInfo as MouseMotionEventInfo;
                if (mouseMotionEventInfo != null)
                {
                    mPacketWriter.Write((short)mouseMotionEventInfo.X);
                    mPacketWriter.Write((short)mouseMotionEventInfo.Y);
                    continue;
                }
            }
        }


        bool IsLatencyAdjustmentFrame
        {
            get
            {
                return mNextLatencyAdjustmentFrame == mGame.CurrentFrameNumber;
            }
        }

        void AdjustLatency()
        {
            Debug.Assert(IsLatencyAdjustmentFrame);

            int maxStallCount = 0;
            int maxAverageOwd = 0;

            foreach (GamerInfo gamerInfo in GamerArray)
            {
                if (gamerInfo.StallCount > maxStallCount) maxStallCount = gamerInfo.StallCount;
                if (gamerInfo.AverageOwd > maxAverageOwd) maxAverageOwd = gamerInfo.AverageOwd;
            }

            // DEBUG
            int prevLatency = mLatency;

            if (maxStallCount > 0)
            {
                mLatency += maxStallCount;
            }
            else
            {
                mLatency = (int)(0.6 * (double)(mLatency - maxAverageOwd) + 1.0);
            }

            // DEBUG OUTPUT
            if (prevLatency != mLatency) Console.WriteLine("Latency readjusted to " + mLatency);

            if (mLatency < 1) mLatency = 1;
            if (mLatency > MaximumLatency) mLatency = MaximumLatency;

            mNextLatencyAdjustmentFrame = mGame.CurrentFrameNumber + mLatency;
            mAverageOwd = CurrentAverageOneWayDelay;

            mLastLocalEvents = mLocalEvents;
            mLocalEvents = new List<EventInfo>();
        }



        List<EventInfo> GetEventsFromInput()
        {
            List<EventInfo> events = new List<EventInfo>();

            // 1. Find the keyboard differences; written by Peter.

            KeyboardState keyState = Keyboard.GetState();

            List<Keys> pressedKeys = new List<Keys>();
            List<Keys> releasedKeys = new List<Keys>();

            Keys[] pressedKeysArray = keyState.GetPressedKeys();
            foreach (Keys k in pressedKeysArray)
            {
                if (!mLastPressedKeys.Contains(k)) pressedKeys.Add(k);
                else mLastPressedKeys.Remove(k);
            }

            releasedKeys = mLastPressedKeys;

            foreach (Keys key in pressedKeys)
            {
                events.Add(new KeyboardEventInfo(LocalGamer, mGame.CurrentFrameNumber, key, true));
            }
            foreach (Keys key in releasedKeys)
            {
                events.Add(new KeyboardEventInfo(LocalGamer, mGame.CurrentFrameNumber, key, false));
            }

            // 2. Find the mouse differences.

            MouseState mouseState = Mouse.GetState();

            bool leftButtonPressed = mouseState.LeftButton == ButtonState.Pressed;
            if (leftButtonPressed != mLastLeftButtonPressed)
            {
                events.Add(new MouseButtonEventInfo(LocalGamer, mGame.CurrentFrameNumber, MouseButton.Left, leftButtonPressed));
            }

            bool rightButtonPressed = mouseState.LeftButton == ButtonState.Pressed;
            if (rightButtonPressed != mLastRightButtonPressed)
            {
                events.Add(new MouseButtonEventInfo(LocalGamer, mGame.CurrentFrameNumber, MouseButton.Right, rightButtonPressed));
            }

            bool middleButtonPressed = mouseState.LeftButton == ButtonState.Pressed;
            if (middleButtonPressed != mLastMiddleButtonPressed)
            {
                events.Add(new MouseButtonEventInfo(LocalGamer, mGame.CurrentFrameNumber, MouseButton.Middle, middleButtonPressed));
            }

            int mousePositionX = mouseState.X;
            int mousePositionY = mouseState.Y;
            if (mousePositionX != mLastMousePositionX || mousePositionY != mLastMousePositionY)
            {
                events.Add(new MouseMotionEventInfo(LocalGamer, mGame.CurrentFrameNumber, mousePositionX, mousePositionY));
            }

            // 3. Save the current peripheral state.

            mLastPressedKeys = new List<Keys>(pressedKeysArray);
            mLastLeftButtonPressed = leftButtonPressed;
            mLastRightButtonPressed = rightButtonPressed;
            mLastMiddleButtonPressed = middleButtonPressed;
            mLastMousePositionX = mousePositionX;
            mLastMousePositionY = mousePositionY;

            return events;
        }

        void SendLocalEvents()
        {
            SendLocalEvents((NetworkGamer)null);
        }

        void SendLocalEvents(List<NetworkGamer> recipicents)
        {
            foreach (NetworkGamer gamer in recipicents)
            {
                SendLocalEvents(gamer);
            }
        }

        void SendLocalEvents(NetworkGamer recipient)
        {
            List<EventInfo> events = new List<EventInfo>(mLocalEvents);
            events.AddRange(mLastLocalEvents);

            WriteEventPacket(events);

            if (recipient != null)
            {
                LocalGamer.SendData(mPacketWriter, SendDataOptions.Reliable, recipient);
            }
            else
            {
                LocalGamer.SendData(mPacketWriter, SendDataOptions.None);
            }
        }


        bool HaveNeededEvents
        {
            get
            {
                long currentFrame = mGame.CurrentFrameNumber;

                foreach (GamerInfo gamerInfo in mGamers.Values)
                {
                    if (gamerInfo.HighestFrameNumber < currentFrame) return false;
                }

                return true;
            }
        }

        void ApplyEvents()
        {
            int index = EventArrayIndex;

            foreach (GamerInfo gamerInfo in GamerArray)
            {
                if (gamerInfo.Events[index] == null) continue;

                foreach (EventInfo eventInfo in gamerInfo.Events[index])
                {
                    KeyboardEventInfo keyboardEventInfo = eventInfo as KeyboardEventInfo;
                    if (keyboardEventInfo != null)
                    {
                        mGame.ApplyKeyInput(gamerInfo, keyboardEventInfo.Key, keyboardEventInfo.IsKeyDown);
                        continue;
                    }

                    MouseButtonEventInfo mouseButtonEventInfo = eventInfo as MouseButtonEventInfo;
                    if (mouseButtonEventInfo != null)
                    {
                        mGame.ApplyMouseButtonInput(gamerInfo, mouseButtonEventInfo.IsButtonDown);
                        continue;
                    }

                    MouseMotionEventInfo mouseMotionEventInfo = eventInfo as MouseMotionEventInfo;
                    if (mouseMotionEventInfo != null)
                    {
                        mGame.ApplyMouseLocationInput(gamerInfo, mouseMotionEventInfo.X, mouseMotionEventInfo.Y);
                        continue;
                    }
                }

                gamerInfo.Events[index] = null;
            }
        }


        int CurrentAverageOneWayDelay
        {
            get
            {
                Debug.Assert(mNetworkSession != null);

                double numRemoteGamersTwice = 2 * mNetworkSession.RemoteGamers.Count;
                double averageOwd = 0;

                foreach (NetworkGamer gamer in mNetworkSession.RemoteGamers)
                {
                    TimeSpan timeSpan = gamer.RoundtripTime;
                    averageOwd += timeSpan.TotalMilliseconds;
                }

                return (int)(averageOwd / numRemoteGamersTwice / 16.6666);
            }
        }

        #endregion
    }
}