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
{
///
/// A manager class to handle network interactions between peers and
/// lobby/game switching.
///
public class NetworkGame
{
// Public methods and properties
#region Public Methods
///
/// Called when a session has been created or joined using CreateSession() or JoinSession().
///
/// The new session that was created or joined.
/// The NetworkGame that joined the session.
public delegate void JoinedSessionDelegate(NetworkSession session, NetworkGame networkGame);
///
/// Called when sessions are found as a result of calling FindSessions().
///
/// A container of the available sessions.
/// The NetworkGame that searched for the sessions.
public delegate void FoundSessionsDelegate(AvailableNetworkSessionCollection sessions, NetworkGame networkGame);
///
/// Construct a NetworkGame with a lobby and a game.
///
/// Provides an associated lobby to update and draw.
/// Provides a game object to be played over the network.
public NetworkGame(ILobby lobby, IDeterministicGame game)
{
Debug.Assert(lobby != null && game != null);
mLobby = lobby;
mGame = game;
}
///
/// Get the Gamer object for the local player.
///
public LocalNetworkGamer LocalGamer
{
get
{
// TODO: Is this the correct way to get the single local gamer?
return mNetworkSession.LocalGamers[0];
}
}
///
/// Get all the gamers associated with the active network session.
///
public GamerCollection NetworkGamers
{
get
{
return mNetworkSession.AllGamers;
}
}
///
/// 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.
///
/// The delegate/method to call when the session is created.
public void CreateSession(JoinedSessionDelegate callback)
{
CreateSession(mGame.MaximumSupportedPlayers, callback);
}
///
/// 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.
///
/// Provide the maximum number of players allowed to connect.
/// The delegate/method to call when the session is created.
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);
}
///
/// Determine whether or not the network game object is associated with any network session.
///
/// True if there exists a NetworkSession; false otherwise.
public bool HasActiveSession
{
get
{
return mNetworkSession != null;
}
}
///
/// 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)
{
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);
}
///
/// 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.
///
/// Pass the session object to try to join.
/// The delegate/method to call when the search finishes.
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;
}
///
/// 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.
///
public void LeaveSession()
{
Debug.Assert(mNetworkSession != null);
mNetworkSession.Dispose();
mNetworkSession = null;
}
///
/// Set up the network session to simulate 200ms latency and 10% packet loss.
///
public void SimulateBadNetwork()
{
Debug.Assert(mNetworkSession != null);
mNetworkSession.SimulatedLatency = new TimeSpan(0, 0, 0, 0, 200);
mNetworkSession.SimulatedPacketLoss = 0.1f;
}
///
/// Indicate that the game should begin (moving players from the lobby to the game).
/// You must call CreateSession() before calling this.
///
public void StartGame()
{
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();
}
///
/// Manages the network session and allows either the lobby or game to update.
///
/// Pass the time away.
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 */
}
}
}
}
///
/// 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.
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);
}
}
}
///
/// 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 a new game to start.
///
void Reset()
{
mLatency = 1;
mNextLatencyAdjustmentFrame = 1;
mStallCount = 0;
mAverageOwd = CurrentAverageOneWayDelay;
mGamers = new Dictionary();
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();
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 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();
}
List GetEventsFromInput()
{
List events = new List();
// 1. Find the keyboard differences; written by Peter.
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);
}
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);
}
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);
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
}
}