MontyHallGame.MontyHallLoadingScreen Class Reference

The loading screen coordinates transitions between the menu system and the game itself. More...

Inheritance diagram for MontyHallGame.MontyHallLoadingScreen:

List of all members.

Public Member Functions
override void	Update (GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
	Updates the loading screen.
override void	Draw (GameTime gameTime)
	Draws the loading screen.
Static Public Member Functions
static void	Load (ScreenManager screenManager, bool loadingIsSlow, PlayerIndex?controllingPlayer, params GameScreen[] screensToLoad)
	Activates the loading screen.

---

Detailed Description

The loading screen coordinates transitions between the menu system and the game itself.

Definition at line 17 of file MontyHallLoadingScreen.cs.

---

Member Function Documentation

override void MontyHallGame.MontyHallLoadingScreen.Draw

(

GameTime

gameTime

)

[virtual]

Draws the loading screen.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 102 of file MontyHallLoadingScreen.cs.

        {
            // If we are the only active screen, that means all the previous screens
            // must have finished transitioning off. We check for this in the Draw
            // method, rather than in Update, because it isn't enough just for the
            // screens to be gone: in order for the transition to look good we must
            // have actually drawn a frame without them before we perform the load.
            if ((ScreenState == ScreenState.Active) &&
                (ScreenManager.GetScreens().Length == 1))
            {
                otherScreensAreGone = true;
            }

            // The gameplay screen takes a while to load, so we display a loading
            // message while that is going on, but the menus load very quickly, and
            // it would look silly if we flashed this up for just a fraction of a
            // second while returning from the game to the menus. This parameter
            // tells us how long the loading is going to take, so we know whether
            // to bother drawing the message.
            if (loadingIsSlow)
            {
                SpriteBatch spriteBatch = ScreenManager.SpriteBatch;
                SpriteFont font = ScreenManager.Fonts["game"];

                const string message = "Loading...";

                // Center the text in the viewport.
                Viewport viewport = ScreenManager.GraphicsDevice.Viewport;
                Vector2 viewportSize = new Vector2(viewport.Width, viewport.Height);
                Vector2 textSize = font.MeasureString(message);
                Vector2 textPosition = (viewportSize - textSize) / 2;

                Color color = new Color(255, 255, 255, TransitionAlpha);

                // Draw the text.
                spriteBatch.Begin();
                spriteBatch.DrawString(font, message, textPosition, color);
                spriteBatch.End();
            }
        }

static void MontyHallGame.MontyHallLoadingScreen.Load	(	ScreenManager	screenManager,
		bool	loadingIsSlow,
		PlayerIndex?	controllingPlayer,
		params GameScreen[]	screensToLoad
	)			[static]

Activates the loading screen.

Definition at line 48 of file MontyHallLoadingScreen.cs.

        {
            // Tell all the current screens to transition off.
            foreach (GameScreen screen in screenManager.GetScreens())
                screen.ExitScreen();

            // Create and activate the loading screen.
            MontyHallLoadingScreen loadingScreen = new MontyHallLoadingScreen(screenManager,
                                                            loadingIsSlow,
                                                            screensToLoad);

            screenManager.AddScreen(loadingScreen, controllingPlayer);
        }

override void MontyHallGame.MontyHallLoadingScreen.Update	(	GameTime	gameTime,
		bool	otherScreenHasFocus,
		bool	coveredByOtherScreen
	)			[virtual]

Updates the loading screen.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 72 of file MontyHallLoadingScreen.cs.

        {
            base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

            // If all the previous screens have finished transitioning
            // off, it is time to actually perform the load.
            if (otherScreensAreGone)
            {
                ScreenManager.RemoveScreen(this);

                foreach (GameScreen screen in screensToLoad)
                {
                    if (screen != null)
                    {
                        ScreenManager.AddScreen(screen, ControllingPlayer);
                    }
                }

                // Once the load has finished, we use ResetElapsedTime to tell
                // the  game timing mechanism that we have just finished a very
                // long frame, and that it should not try to catch up.
                ScreenManager.Game.ResetElapsedTime();
            }
        }

---

The documentation for this class was generated from the following file:

• C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/MontyHallGame/Screens/MontyHallLoadingScreen.cs