void loadGameMenuEntry_Selected(object sender, PlayerIndexEventArgs e)
{
MessageBoxScreen notImplementedMessageBox =
new MessageBoxScreen("Not Implemented", false);
ScreenManager.AddScreen(notImplementedMessageBox, e.PlayerIndex);
}
/// <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 = "Confirm Session";
}
else
{
message = "Leave Session";
}
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("No Session Found", 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>
/// When the user cancels the main menu, ask if they want to exit the game.
/// </summary>
void OnCancel(object sender, PlayerIndexEventArgs e)
{
MessageBoxScreen confirmExitMessageBox =
new MessageBoxScreen(Helper.QuitMessage(), false);
confirmExitMessageBox.Accepted += ConfirmExitMessageBoxAccepted;
ScreenManager.AddScreen(confirmExitMessageBox, e.PlayerIndex);
}
/// <summary>
/// Event handler for when the Quit Game menu entry is selected.
/// </summary>
void QuitGameMenuEntrySelected(object sender, PlayerIndexEventArgs e)
{
MessageBoxScreen confirmQuitMessageBox =
new MessageBoxScreen(Helper.QuitMessage(), false);
confirmQuitMessageBox.Accepted += ConfirmQuitMessageBoxAccepted;
ScreenManager.AddScreen(confirmQuitMessageBox, ControllingPlayer);
}
/// <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("Confirm");
confirmMarketplaceMessageBox.Accepted += delegate
{
Guide.ShowMarketplace(ControllingPlayer.Value);
};
ScreenManager.AddScreen(confirmMarketplaceMessageBox, ControllingPlayer);
}
/// <summary>
/// Handles input for the specified player. In local game modes, this is called
/// just once for the controlling player. In network modes, it can be called
/// more than once if there are multiple profiles playing on the local machine.
/// Returns true if we should continue to handle input for subsequent players,
/// or false if this player has paused the game.
/// </summary>
bool HandlePlayerInput(InputState input, PlayerIndex playerIndex)
{
// Look up inputs for the specified player profile.
KeyboardState keyboardState = input.CurrentKeyboardStates[(int)playerIndex];
GamePadState gamePadState = input.CurrentGamePadStates[(int)playerIndex];
// The game pauses either if the user presses the pause button, or if
// they unplug the active gamepad. This requires us to keep track of
// whether a gamepad was ever plugged in, because we don't want to pause
// on PC if they are playing with a keyboard and have no gamepad at all!
bool gamePadDisconnected = !gamePadState.IsConnected &&
input.GamePadWasConnected[(int)playerIndex];
if (gamePadDisconnected)
{
MessageBoxScreen gamePadDisconectedMessageBox =
new MessageBoxScreen("Gamepad Disconnected", false);
ScreenManager.AddScreen(gamePadDisconectedMessageBox, playerIndex);
return(false);
}
else
{
if (gamePadState.IsConnected)
{
if (gamePadState.IsButtonDown(Buttons.A))
{
loadTitleScreen(playerIndex);
}
}
else
{
if (
keyboardState.IsKeyDown(Keys.Enter)
|
keyboardState.IsKeyDown(Keys.Escape)
|
keyboardState.IsKeyDown(Keys.Space)
)
{
loadTitleScreen(playerIndex);
}
}
}
return(true);
}
/// <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("Confirm");
messageBox.Accepted += ConfirmStartGameMessageBoxAccepted;
ScreenManager.AddScreen(messageBox, gamer.SignedInGamer.PlayerIndex);
}
}
/// <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 MainMenuScreen(),
messageBox);
}
/// <summary>
/// Handles input for the specified player. In local game modes, this is called
/// just once for the controlling player. In network modes, it can be called
/// more than once if there are multiple profiles playing on the local machine.
/// Returns true if we should continue to handle input for subsequent players,
/// or false if this player has paused the game.
/// </summary>
bool HandlePlayerInput(InputState input, PlayerIndex playerIndex)
{
// Look up inputs for the specified player profile.
keyboardState = input.CurrentKeyboardStates[(int)playerIndex];
gamePadState = input.CurrentGamePadStates[(int)playerIndex];
// set the local variable currentPlayerIndex
currentPlayerIndex = playerIndex;
// The game pauses either if the user presses the pause button, or if
// they unplug the active gamepad. This requires us to keep track of
// whether a gamepad was ever plugged in, because we don't want to pause
// on PC if they are playing with a keyboard and have no gamepad at all!
bool gamePadDisconnected = !gamePadState.IsConnected &&
input.GamePadWasConnected[(int)playerIndex];
if (input.IsPauseGame(playerIndex))
{
SoundManager.StopMusic();
ScreenManager.AddScreen(new PauseMenuScreen(networkSession), playerIndex);
return(false);
}
else if (gamePadDisconnected)
{
MessageBoxScreen gamePadDisconectedMessageBox =
new MessageBoxScreen("Disconnected", false);
ScreenManager.AddScreen(gamePadDisconectedMessageBox, playerIndex);
return(false);
}
else
{
// Gamepad found
if (gamePadState.IsConnected)
{
// handle weapon input a gamepad
player.HandleInput(gamePadState);
// handle map input using the keyboard
realtimeMap.HandleInput(keyboardState);
if (currentDoor != null)
{
currentDoor.HandleInput(gamePadState);
}
if (currentSecret != null)
{
currentSecret.HandleInput(gamePadState);
}
}
// use the keyboard
else
{
// handle weapon input using the keyboard
player.HandleInput(keyboardState);
// handle map input using the keyboard
//realtimeMap.HandleInput(keyboardState);
if (currentDoor != null)
{
currentDoor.HandleInput(keyboardState);
}
if (currentSecret != null)
{
currentSecret.HandleInput(keyboardState);
}
}
}
return(true);
}