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); }