/// <summary>
/// Public method called when the user wants to leave the network session.
/// Displays a confirmation message box, then disposes the session, removes
/// the NetworkSessionComponent, and returns them to the main menu screen.
/// </summary>
public static void LeaveSession(ScreenManager screenManager,
PlayerIndex playerIndex)
{
NetworkSessionComponent self = FindSessionComponent(screenManager.Game);
if (self != null)
{
// Display a message box to confirm the user really wants to leave.
string message;
if (self.networkSession.IsHost)
{
message = Resources.ConfirmEndSession;
}
else
{
message = Resources.ConfirmLeaveSession;
}
MessageBoxScreen confirmMessageBox = new MessageBoxScreen(message);
// Hook the messge box ok event to actually leave the session.
confirmMessageBox.Accepted += delegate
{
self.LeaveSession();
};
screenManager.AddScreen(confirmMessageBox, playerIndex);
}
}
/// <summary>
/// Event handler for when the asynchronous find network sessions
/// operation has completed.
/// </summary>
void FindSessionsOperationCompleted(object sender,
OperationCompletedEventArgs e)
{
GameScreen nextScreen;
try
{
// End the asynchronous find network sessions operation.
AvailableNetworkSessionCollection availableSessions =
NetworkSession.EndFind(e.AsyncResult);
if (availableSessions.Count == 0)
{
// If we didn't find any sessions, display an error.
availableSessions.Dispose();
nextScreen = new MessageBoxScreen(Resources.NoSessionsFound, false);
}
else
{
// If we did find some sessions, proceed to the JoinSessionScreen.
nextScreen = new JoinSessionScreen(availableSessions);
}
}
catch (Exception exception)
{
nextScreen = new NetworkErrorScreen(exception);
}
ScreenManager.AddScreen(nextScreen, ControllingPlayer);
}
/// <summary>
/// Event handler for when the Quit Game menu entry is selected.
/// </summary>
void QuitGameMenuEntrySelected(object sender, PlayerIndexEventArgs e)
{
MessageBoxScreen confirmQuitMessageBox =
new MessageBoxScreen(Resources.ConfirmQuitGame);
confirmQuitMessageBox.Accepted += ConfirmQuitMessageBoxAccepted;
ScreenManager.AddScreen(confirmQuitMessageBox, ControllingPlayer);
}
/// <summary>
/// When the user cancels the main menu, ask if they want to exit the sample.
/// </summary>
protected override void OnCancel(PlayerIndex playerIndex)
{
const string message = "Are you sure you want to exit?";
MessageBoxScreen confirmExitMessageBox = new MessageBoxScreen(message);
confirmExitMessageBox.Accepted += ConfirmExitMessageBoxAccepted;
ScreenManager.AddScreen(confirmExitMessageBox, playerIndex);
}
private void GameOver()
{
MessageBoxScreen youwinMessageBox;
youwinMessageBox = new MessageBoxScreen(" Game over!\nYou captured candy canes!\nA button = Exit\nB button = Restart", false);
//youwinMessageBox = new MessageBoxScreen(" Game over!\nYou captured " + score.ToString() + " candy canes!\nA button = Exit\nB button = Restart", false);
youwinMessageBox.Accepted += youwinMessageBoxAccepted;
youwinMessageBox.Cancelled += youwinMessageBoxCancelled;
ScreenManager.AddScreen(youwinMessageBox, Global_Variables.playerWhoBeganGame);
}
/// <summary>
/// LIVE networking is not supported in trial mode. Rather than just giving
/// the user an error, this function asks if they want to purchase the full
/// game, then takes them to Marketplace where they can do that. Once the
/// Guide is active, the user can either make the purchase, or cancel it.
/// When the Guide closes, ProfileSignInScreen.Update will notice that
/// Guide.IsVisible has gone back to false, at which point it will check if
/// the game is still in trial mode, and either exit the screen or proceed
/// forward accordingly.
/// </summary>
void ShowMarketplace()
{
MessageBoxScreen confirmMarketplaceMessageBox =
new MessageBoxScreen(Resources.ConfirmMarketplace);
confirmMarketplaceMessageBox.Accepted += delegate
{
Guide.ShowMarketplace(ControllingPlayer.Value);
};
ScreenManager.AddScreen(confirmMarketplaceMessageBox, ControllingPlayer);
}
void unlockgameMenuEntrySelected(object sender, PlayerIndexEventArgs e)
{
if (Guide.IsTrialMode == true &&
PlayerIndexExtensions.CanBuyGame(e.PlayerIndex)
)
{
Guide.ShowMarketplace(e.PlayerIndex);
}
else if (Guide.IsTrialMode)
{
MessageBoxScreen purchaseMessageBox;
purchaseMessageBox = new MessageBoxScreen("Please sign into an Xbox Live enabled profile that can purchase content.\nA button = Choose an Account\nB button = Cancel", false);
purchaseMessageBox.Accepted += purchaseMessageBoxAccepted;
purchaseMessageBox.Cancelled += purchaseMessageBoxCancelled;
ScreenManager.AddScreen(purchaseMessageBox, e.PlayerIndex);
}
}
/// <summary>
/// Handle MenuSelect inputs by marking ourselves as ready.
/// </summary>
void HandleMenuSelect(LocalNetworkGamer gamer)
{
if (!gamer.IsReady)
{
gamer.IsReady = true;
}
else if (gamer.IsHost)
{
// The host has an option to force starting the game, even if not
// everyone has marked themselves ready. If they press select twice
// in a row, the first time marks the host ready, then the second
// time we ask if they want to force start.
MessageBoxScreen messageBox = new MessageBoxScreen(
Resources.ConfirmForceStartGame);
messageBox.Accepted += ConfirmStartGameMessageBoxAccepted;
ScreenManager.AddScreen(messageBox, gamer.SignedInGamer.PlayerIndex);
}
}
void multiplayerMenuEntrySelected(object sender, PlayerIndexEventArgs e)
{
if (Guide.IsTrialMode == true &&
PlayerIndexExtensions.CanBuyGame(e.PlayerIndex)
)
{
Guide.ShowMarketplace(e.PlayerIndex);
}
if (Guide.IsTrialMode)
{
MessageBoxScreen purchaseMessageBox;
purchaseMessageBox = new MessageBoxScreen("Multiplayer gameplay is not available in the\ntrial version. Please purchase the game!\nA button = Okay", false);
purchaseMessageBox.Accepted += purchaseMessageBoxCancelled;
purchaseMessageBox.Cancelled += purchaseMessageBoxCancelled;
ScreenManager.AddScreen(purchaseMessageBox, e.PlayerIndex);
}
if (Guide.IsTrialMode == false)
{
BackgroundScreen.player1isplaying = false;
BackgroundScreen.player2isplaying = false;
BackgroundScreen.player3isplaying = false;
BackgroundScreen.player4isplaying = false;
Global_Variables.playerWhoBeganGame = e.PlayerIndex;
switch (e.PlayerIndex)
{
case PlayerIndex.One:
Global_Variables.playerWhoBeganGameZeroIndexedInt = 0;
break;
case PlayerIndex.Two:
Global_Variables.playerWhoBeganGameZeroIndexedInt = 1;
break;
case PlayerIndex.Three:
Global_Variables.playerWhoBeganGameZeroIndexedInt = 2;
break;
case PlayerIndex.Four:
Global_Variables.playerWhoBeganGameZeroIndexedInt = 3;
break;
}
BackgroundScreen.playerwhoselectedplay = e.PlayerIndex;
if (BackgroundScreen.playerwhoselectedplay == PlayerIndex.One)
{
BackgroundScreen.player1isplaying = true;
}
if (BackgroundScreen.playerwhoselectedplay == PlayerIndex.Two)
{
BackgroundScreen.player2isplaying = true;
}
if (BackgroundScreen.playerwhoselectedplay == PlayerIndex.Three)
{
BackgroundScreen.player3isplaying = true;
}
if (BackgroundScreen.playerwhoselectedplay == PlayerIndex.Four)
{
BackgroundScreen.player4isplaying = true;
}
Guide.ShowSignIn(4, false);
LoadingScreen.Load(ScreenManager, true, e.PlayerIndex,
new Black(null));
}
}
/// <summary>
/// Internal method for leaving the network session. This disposes the
/// session, removes the NetworkSessionComponent, and returns the user
/// to the main menu screen.
/// </summary>
void LeaveSession()
{
// Destroy this NetworkSessionComponent.
Dispose();
// If we have a sessionEndMessage string explaining why the session has
// ended (maybe this was a network disconnect, or perhaps the host kicked
// us out?) create a message box to display this reason to the user.
MessageBoxScreen messageBox;
if (!string.IsNullOrEmpty(sessionEndMessage))
{
messageBox = new MessageBoxScreen(sessionEndMessage, false);
}
else
{
messageBox = null;
}
// At this point we want to return the user all the way to the main
// menu screen. But what if they just joined a session? In that case
// they went through this flow of screens:
//
// - MainMenuScreen
// - CreateOrFindSessionsScreen
// - JoinSessionScreen (if joining, skipped if creating a new session)
// - LobbyScreeen
//
// If we have these previous screens on the history stack, and the user
// backs out of the LobbyScreen, the right thing is just to pop off the
// intermediate screens, returning them to the existing MainMenuScreen
// instance without bothering to reload everything. But if the user is
// in gameplay, or has been in gameplay and then returned to the lobby,
// the screen stack will have been emptied.
//
// To do the right thing in both cases, we scan through the screen history
// stack looking for a MainMenuScreen. If we find one, we pop any
// subsequent screens so as to return back to it, while if we don't
// find it, we just reset everything via the LoadingScreen.
GameScreen[] screens = screenManager.GetScreens();
// Look for the MainMenuScreen.
for (int i = 0; i < screens.Length; i++)
{
if (screens[i] is MainMenuScreen)
{
// If we found one, pop everything since then to return back to it.
for (int j = i + 1; j < screens.Length; j++)
{
screens[j].ExitScreen();
}
// Display the why-did-the-session-end message box.
if (messageBox != null)
{
screenManager.AddScreen(messageBox, null);
}
return;
}
}
// If we didn't find an existing MainMenuScreen, reload everything.
// The why-did-the-session-end message box will be displayed after
// the loading screen has completed.
LoadingScreen.Load(screenManager, false, null, new BackgroundScreen(),
new MainMenuScreen(),
messageBox);
}