private static LidgrenSession EndCreateOrJoin(IAsyncResult result)
{
LidgrenSession session = null;
try
{
var asyncResult = (AsyncResult)result;
result.AsyncWaitHandle.WaitOne();
if (asyncResult.AsyncDelegate is AsynchronousCreate)
{
session = ((AsynchronousCreate)asyncResult.AsyncDelegate).EndInvoke(result);
}
else if (asyncResult.AsyncDelegate is AsynchronousJoin)
{
session = ((AsynchronousJoin)asyncResult.AsyncDelegate).EndInvoke(result);
}
}
finally
{
result.AsyncWaitHandle.Close();
}
return(session);
}
/// <summary>
/// Creates a wide area network session
/// </summary>
/// <param name="maxPlayers">The total maximum players for this session</param>
/// <param name="sessionProperties">The SessionProperties that will be used to find this session on the network. Can be null</param>
/// <remarks>it doesn't yet support multiple local players</remarks>
public override void CreateWanSession(int maxPlayers, SessionProperties sessionProperties)
{
IPAddress ipAddress;
var host = NetUtility.GetMyAddress(out ipAddress);
_networkSessionLocker = CreatingSession;
LidgrenSession.BeginCreate(host.ToString(), SessionType.WideAreaNetwork, 1, maxPlayers, 0, sessionProperties, OnLidgrenSessionCreated, _networkSessionLocker);
}
private void OnLidgrenSessionsFound(IAsyncResult ar)
{
var foundSessions = new List <AvailableSession>(LidgrenSession.EndFind(ar));
// cleanup the temp session, this might could be reused.
CurrentSession.EndSession(); // not sure if this is needed
CurrentSession = null;
OnSessionsFound(foundSessions);
}
/// <summary>
/// Sends a Find query on the network interface to look for AvailableSession instances asynchrnously
/// </summary>
/// <param name="sessionType">The SessionType we're looking for</param>
/// <param name="maxLocalPlayers">The Maximum local players that can be added to the session used to filter sessions that have a limited number of opened public slots</param>
/// <param name="sessionProperties">The SessionProperties that will be used to filter query results. Can be null</param>
/// <param name="host">The for WAN session discovery</param>
/// <param name="port">The for WAN session discovery</param>
public void FindSessionsWan(SessionType sessionType, int maxLocalPlayers, SessionProperties sessionProperties, string host = null, int port = ServerPort)
{
if (CurrentSession != null)
{
throw new CoreException("Session is already running");
}
_networkSessionLocker = FindingSessions;
LidgrenSession.BeginFindWan(sessionType, maxLocalPlayers, sessionProperties, host, port, OnLidgrenSessionsFound, _networkSessionLocker);
}
/// <summary>
/// Sends a Join query to the Session asynchronously
/// </summary>
/// <param name="availableSession">The Session we are trying to join</param>
public override void JoinSession(AvailableSession availableSession)
{
if (CurrentSession != null)
{
throw new CoreException("Session is already running");
}
_networkSessionLocker = JoiningSession;
LidgrenSession.BeginJoin(availableSession as LidgrenAvailableSession, OnLidgrenSessionJoined, _networkSessionLocker);
}
/// <summary>
/// Sends a Find query on the network interface to look for AvailableSession instances asynchrnously
/// </summary>
/// <param name="sessionType">The SessionType we're looking for</param>
/// <param name="maxLocalPlayers">The Maximum local players that can be added to the session used to filter sessions that have a limited number of opened public slots</param>
/// <param name="sessionProperties">The SessionProperties that will be used to filter query results. Can be null</param>
public override void FindSessions(SessionType sessionType, int maxLocalPlayers, SessionProperties sessionProperties)
{
if (CurrentSession != null)
{
throw new CoreException("Session is already running");
}
_networkSessionLocker = FindingSessions;
LidgrenSession.BeginFind(sessionType, maxLocalPlayers, sessionProperties, OnLidgrenSessionsFound, _networkSessionLocker);
}
/// <summary>
/// Creates a Single Player Session
/// </summary>
/// <remarks>No network resources will be used</remarks>
public override void CreateSinglePlayerSession()
{
if (CurrentSession != null)
{
throw new CoreException("Session is already running");
}
IPAddress ipAddress;
var host = NetUtility.GetMyAddress(out ipAddress);
_networkSessionLocker = CreatingSession;
LidgrenSession.BeginCreate(host.ToString(), SessionType.SinglePlayer, 1, 1, 0, new SessionProperties(), OnLidgrenSessionCreated, _networkSessionLocker);
}
/// <summary>
/// Sends a Find query on the network interface to look for AvailableSession instances asynchrnously
/// </summary>
/// <param name="sessionType">The SessionType we're looking for</param>
/// <param name="maxLocalPlayers">The Maximum local players that can be added to the session used to filter sessions that have a limited number of opened public slots</param>
/// <param name="sessionProperties">The SessionProperties that will be used to filter query results. Can be null</param>
public override void FindSessions(SessionType sessionType, int maxLocalPlayers, SessionProperties sessionProperties)
{
if (CurrentSession != null)
{
throw new CoreException("Session is already running");
}
if (sessionType == SessionType.WideAreaNetwork)
{
throw new NotImplementedException("Use FindSessionsWan method instead");
}
// Create a temporary session to listen for discovery messages
CurrentSession = new LidgrenSession(sessionType, maxLocalPlayers, 0, sessionProperties);
_networkSessionLocker = FindingSessions;
LidgrenSession.BeginFind(sessionType, maxLocalPlayers, sessionProperties, OnLidgrenSessionsFound, _networkSessionLocker);
}
internal static LidgrenSession Join(LidgrenAvailableSession availableSession)
{
var session = new LidgrenSession(availableSession.HostName, availableSession.SessionType, availableSession.CurrentGamerCount + availableSession.OpenPublicSlots + availableSession.OpenPrivateSlots, 0, availableSession.Properties, false);
return session;
}
private static LidgrenSession Create(string serverHost, SessionType sessionType, int maxGamers, int privateReservedSlots, SessionProperties sessionProperties, bool isHost)
{
var session = new LidgrenSession(serverHost, sessionType, maxGamers, privateReservedSlots, sessionProperties, isHost);
return session;
}
private static LidgrenSession Create(string serverHost, SessionType sessionType, int maxGamers, int privateReservedSlots, SessionProperties sessionProperties, bool isHost)
{
var session = new LidgrenSession(serverHost, sessionType, maxGamers, privateReservedSlots, sessionProperties, isHost);
return(session);
}
internal static LidgrenSession Join(LidgrenAvailableSession availableSession)
{
var session = new LidgrenSession(availableSession.HostName, availableSession.SessionType, availableSession.CurrentGamerCount + availableSession.OpenPublicSlots + availableSession.OpenPrivateSlots, 0, availableSession.Properties, false);
return(session);
}
private void OnLidgrenSessionCreated(IAsyncResult result)
{
CurrentSession = LidgrenSession.EndCreate(result);
}
private void OnLidgrenSessionJoined(IAsyncResult ar)
{
CurrentSession = LidgrenSession.EndJoin(ar);
OnSessionJoined();
}
private void OnLidgrenSessionsFound(IAsyncResult ar)
{
var foundSessions = new List <AvailableSession>(LidgrenSession.EndFind(ar));
OnSessionsFound(foundSessions);
}
/// <summary>
/// Sends a Find query on the network interface to look for AvailableSession instances asynchrnously
/// </summary>
/// <param name="sessionType">The SessionType we're looking for</param>
/// <param name="maxLocalPlayers">The Maximum local players that can be added to the session used to filter sessions that have a limited number of opened public slots</param>
/// <param name="sessionProperties">The SessionProperties that will be used to filter query results. Can be null</param>
public override void FindSessions(SessionType sessionType, int maxLocalPlayers, SessionProperties sessionProperties)
{
if (CurrentSession != null)
throw new CoreException("Session is already running");
if (sessionType == SessionType.WideAreaNetwork)
throw new NotImplementedException("Use FindSessionsWan method instead");
// Create a temporary session to listen for discovery messages
CurrentSession = new LidgrenSession(sessionType, maxLocalPlayers, 0, sessionProperties);
_networkSessionLocker = FindingSessions;
LidgrenSession.BeginFind(sessionType, maxLocalPlayers, sessionProperties, OnLidgrenSessionsFound, _networkSessionLocker);
}
