X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=Project06%2FCS%203505%20Project%2006%2FCS%203505%20Project%2006%2FNetworkGame.cs;h=72a588cf62f6fcbab846b40794fd387dbf529a52;hb=0e2cd798178ca471d26ea33ee849365c3b9b593e;hp=95d843ec0b851cdec0efe96de456e6bbfe1f8b93;hpb=fc7104b36d66d536d38ba38a4afae588c437f6c6;p=chaz%2Fcarfire diff --git a/Project06/CS 3505 Project 06/CS 3505 Project 06/NetworkGame.cs b/Project06/CS 3505 Project 06/CS 3505 Project 06/NetworkGame.cs index 95d843e..72a588c 100644 --- a/Project06/CS 3505 Project 06/CS 3505 Project 06/NetworkGame.cs +++ b/Project06/CS 3505 Project 06/CS 3505 Project 06/NetworkGame.cs @@ -8,6 +8,7 @@ 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 { @@ -17,36 +18,8 @@ namespace CS_3505_Project_06 /// public class NetworkGame { - // Private class variable members - #region Instance Variables - - NetworkSession mNetworkSession; - - JoinedSessionDelegate mJoinedSessionDelegate; - FoundSessionsDelegate mFoundSessionsDelegate; - - ILobby mLobby; - IDeterministicGame mGame; - - List mLastPressedKeys = new List(); - bool mLastButtonPressed; - - int mLatency; - long mNextLatencyAdjustmentFrame; - int mStallCount; - int mAverageOwd; - - TimeSpan mTargetTimeSpan = new TimeSpan(166666); - public TimeSpan TargetTimeSpan - { - get - { - return mTargetTimeSpan; - } - } - - #endregion - + // Public methods and properties + #region Public Methods /// /// Called when a session has been created or joined using CreateSession() or JoinSession(). @@ -131,10 +104,17 @@ namespace CS_3505_Project_06 mNetworkSession = NetworkSession.EndCreate(result); mNetworkSession.AllowHostMigration = true; mNetworkSession.AllowJoinInProgress = false; - + mNetworkSession.GameStarted += new EventHandler(mNetworkSession_GameStarted); mJoinedSessionDelegate(mNetworkSession, this); } + + //gamestarted event + void mNetworkSession_GameStarted(object sender, GameStartedEventArgs e) + { + Reset(); + } + /// /// Determine whether or not the network game object is associated with any network session. /// @@ -149,7 +129,8 @@ namespace CS_3505_Project_06 /// - /// Find available sessions to join. + /// Find available sessions to join. You should not already be in a session when + /// calling this method; call LeaveSession first. /// /// The delegate/method to call when the search finishes. public void FindSessions(FoundSessionsDelegate callback) @@ -167,7 +148,7 @@ namespace CS_3505_Project_06 /// /// Join a network session found using FindSessions(). This is for joining a game that - /// somebody else has already started hosting. + /// somebody else has already started hosting. You must not already be in a session. /// /// Pass the session object to try to join. /// The delegate/method to call when the search finishes. @@ -186,12 +167,14 @@ namespace CS_3505_Project_06 mJoinedSessionDelegate(mNetworkSession, this); mJoinedSessionDelegate = null; + + mNetworkSession.GameStarted += new EventHandler(mNetworkSession_GameStarted); } /// /// Leave and dispose of any currently associated network session. You will find yourself - /// back in the lobby. + /// back in the lobby. You must already be in a session to leave it. /// public void LeaveSession() { @@ -220,10 +203,23 @@ namespace CS_3505_Project_06 /// public void StartGame() { - Debug.Assert(mNetworkSession != null && mNetworkSession.IsHost); + Debug.Assert(mNetworkSession != null && mNetworkSession.IsHost && + mNetworkSession.AllGamers.Count >= mGame.MinimumSupportedPlayers && + mNetworkSession.IsEveryoneReady); + ForceStartGame(); + } + + /// + /// Indicate that the game should begin. This is like StartGame() without the sanity + /// checks. Use this for debugging. + /// + public void ForceStartGame() + { mNetworkSession.StartGame(); mNetworkSession.ResetReady(); + + //Reset(); } @@ -240,34 +236,54 @@ namespace CS_3505_Project_06 else { mNetworkSession.Update(); - ReadPackets(); + HandleIncomingPackets(); if (mNetworkSession.SessionState == NetworkSessionState.Lobby) { - if (mNetworkSession.IsHost && - mNetworkSession.AllGamers.Count >= mGame.MinimumSupportedPlayers && - mNetworkSession.IsEveryoneReady) - { - mNetworkSession.StartGame(); - mNetworkSession.ResetReady(); - } - else - { - mLobby.Update(gameTime, this); - } + 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; + 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 */ } } } @@ -293,189 +309,633 @@ namespace CS_3505_Project_06 } else if (mNetworkSession.SessionState == NetworkSessionState.Playing) { - mLobby.Draw(spriteBatch); + mGame.Draw(spriteBatch); } } } + /// + /// Get the chat messages that have been receive since the last time this + /// method was called. + /// + /// List container of the chat messages. + public List ReceiveChats() + { + List chats = mChatPackets; + mChatPackets = new List(); + return chats; + } + + /// + /// Send a chat message to all gamers in the session. You should already be + /// in a session before calling this method. + /// + /// The text of the message. + public void SendChat(String message) + { + WriteChatPacket(message); + LocalGamer.SendData(mPacketWriter, SendDataOptions.ReliableInOrder); + } + + /// + /// Send a chat message to a specific gamer in the session. You should already + /// be in a session before calling this method. + /// + /// The text of the message. + /// The gamer to receive the message. + 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 mChatPackets = new List(); + + List mLocalEvents = new List(); + List mLastLocalEvents = new List(); + + List mLastPressedKeys = new List(); + 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 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[] Events = new List[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 /// - /// Reinitialize the private variables in preparation for new game to start. + /// Reinitialize the private variables in preparation for a new game to start. /// - private void Reset() + void Reset() { mLatency = 1; mNextLatencyAdjustmentFrame = 1; mStallCount = 0; - mAverageOwd = AverageOneWayDelay; + mAverageOwd = CurrentAverageOneWayDelay; - // TODO: The game object needs to be reset, too. - //mGame.ResetGame(playerIdentifiers, playerIdentifiers[0]); + mGamers = new Dictionary(); + foreach (NetworkGamer gamer in NetworkGamers) + { + mGamers.Add(gamer.Id, new GamerInfo(gamer)); + } + + mGame.ResetGame(GamerArray, LocalGamerInfo); } - /// - /// 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. - /// - /// Pass the time away. - /// The sprite batch. - private void ReadPackets() + void HandleIncomingPackets() { - PacketReader packetReader = new PacketReader(); + LocalNetworkGamer localGamer = LocalGamer; - foreach (LocalNetworkGamer gamer in mNetworkSession.LocalGamers) + while (localGamer.IsDataAvailable) { - while (gamer.IsDataAvailable) + NetworkGamer sender; + + localGamer.ReceiveData(mPacketReader, out sender); + GamerInfo senderInfo = mGamers[sender.Id]; + + PacketType packetId = (PacketType)mPacketReader.ReadByte(); + switch (packetId) { - NetworkGamer sender; + case PacketType.Chat: - gamer.ReceiveData(packetReader, out sender); - byte packetId = packetReader.ReadByte(); + short messageLength = mPacketReader.ReadInt16(); + char[] message = mPacketReader.ReadChars(messageLength); - switch (packetId) - { - // Chat Packet - case 1: - short messageLength = packetReader.ReadInt16(); - char[] message = packetReader.ReadChars(messageLength); - - ChatPacket chatPacket; - chatPacket.sender = sender; - chatPacket.message = new String(message); - break; + ChatInfo chatPacket = new ChatInfo(sender, new String(message)); + mChatPackets.Add(chatPacket); + break; - // Event Packet - case 2: - short stallCount = packetReader.ReadInt16(); - short averageOwd = packetReader.ReadInt16(); - int frameNumber = packetReader.ReadInt32(); - byte numEvents = packetReader.ReadByte(); + case PacketType.Event: - for (byte i = 0; i < numEvents; ++i) + 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) { - ReadEvent(packetReader, sender); + int index = EventArrayIndex; + if (senderInfo.Events[index] == null) senderInfo.Events[index] = new List(); + senderInfo.Events[index].Add(eventInfo); } + } - break; + senderInfo.StallCount = stallCount; + senderInfo.AverageOwd = averageOwd; + senderInfo.HighestFrameNumber = frameNumber; + break; - // Stall Packet - case 3: - byte numStalledPeers = packetReader.ReadByte(); - byte[] stalledPeers = packetReader.ReadBytes(numStalledPeers); + case PacketType.Stall: - break; - } + byte numStalledPeers = mPacketReader.ReadByte(); + byte[] stalledPeers = mPacketReader.ReadBytes(numStalledPeers); + + // TODO + + break; + + default: + + Console.WriteLine("Received unknown packet type: " + (int)packetId); + break; } } } - private void ReadEvent(PacketReader packetReader, NetworkGamer sender) + + int EventArrayIndex + { + get { return (int)(mGame.CurrentFrameNumber % MaximumLatency); } + } + + EventInfo ReadEvent(PacketReader packetReader, NetworkGamer sender) { - byte eventId = packetReader.ReadByte(); - long applicationFrame = packetReader.ReadInt32(); + EventType eventId = (EventType)packetReader.ReadByte(); + long frameNumber = packetReader.ReadInt32(); switch (eventId) { - // Key Down - case 1: + case EventType.KeyDown: + int keyCode1 = packetReader.ReadInt32(); + return new KeyboardEventInfo(sender, frameNumber, (Keys)keyCode1, true); - break; + case EventType.KeyUp: - // Key Up - case 2: int keyCode2 = packetReader.ReadInt32(); + return new KeyboardEventInfo(sender, frameNumber, (Keys)keyCode2, false); - break; + case EventType.MouseDown: - // Mouse Down - case 3: byte buttonId1 = packetReader.ReadByte(); + return new MouseButtonEventInfo(sender, frameNumber, (MouseButton)buttonId1, true); - break; + case EventType.MouseUp: - // Mouse Up - case 4: byte buttonId2 = packetReader.ReadByte(); + return new MouseButtonEventInfo(sender, frameNumber, (MouseButton)buttonId2, false); - break; + case EventType.MouseMove: - // Mouse Move - case 5: short x = packetReader.ReadInt16(); short y = packetReader.ReadInt16(); + return new MouseMotionEventInfo(sender, frameNumber, x, y); + + default: - break; + Console.WriteLine("Received unknown event type: " + (int)eventId); + return null; } } - private bool IsLatencyAdjustmentFrame + void WriteChatPacket(String message) + { + mPacketWriter.Write((byte)PacketType.Chat); + mPacketWriter.Write((short)message.Length); + mPacketWriter.Write(message.ToCharArray()); + } + + void WriteEventPacket(List 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 { - // TODO - return false; + return mNextLatencyAdjustmentFrame == mGame.CurrentFrameNumber; } } - private void AdjustLatency() + void AdjustLatency() { - // TODO + 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(); } - private void SendLocalEvents() + + List GetEventsFromInput() { - // TODO: Not finished. + List events = new List(); - KeyboardState keyState = Keyboard.GetState(); - MouseState mouseState = Mouse.GetState(); + // 1. Find the keyboard differences; written by Peter. - // Make a list of the keys pressed or released this frame. + KeyboardState keyState = Keyboard.GetState(); List pressedKeys = new List(); List releasedKeys = new List(); Keys[] pressedKeysArray = keyState.GetPressedKeys(); foreach (Keys k in pressedKeysArray) - if (!mLastPressedKeys.Contains(k)) - pressedKeys.Add(k); - else - mLastPressedKeys.Remove(k); + { + 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(pressedKeysArray); + mLastLeftButtonPressed = leftButtonPressed; + mLastRightButtonPressed = rightButtonPressed; + mLastMiddleButtonPressed = middleButtonPressed; + mLastMousePositionX = mousePositionX; + mLastMousePositionY = mousePositionY; + + return events; + } + + void SendLocalEvents() + { + SendLocalEvents((NetworkGamer)null); + } - bool buttonPressed = mouseState.LeftButton == ButtonState.Pressed; + void SendLocalEvents(List recipicents) + { + foreach (NetworkGamer gamer in recipicents) + { + SendLocalEvents(gamer); + } } + void SendLocalEvents(NetworkGamer recipient) + { + List events = new List(mLocalEvents); + events.AddRange(mLastLocalEvents); + + WriteEventPacket(events); - private bool HaveNeededEvents + if (recipient != null) + { + LocalGamer.SendData(mPacketWriter, SendDataOptions.Reliable, recipient); + } + else + { + LocalGamer.SendData(mPacketWriter, SendDataOptions.None); + } + } + + + bool HaveNeededEvents { get { - // TODO + long currentFrame = mGame.CurrentFrameNumber; + + foreach (GamerInfo gamerInfo in mGamers.Values) + { + if (gamerInfo.HighestFrameNumber < currentFrame) return false; + } + return true; } } - private void ApplyEvents() + void ApplyEvents() { - // TODO + 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; + } } - private int AverageOneWayDelay + int CurrentAverageOneWayDelay { get { - // TODO - return 12; + 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); } }