PendulumGame.PendulumLoadingScreen Class Reference

The loading screen coordinates transitions between the menu system and the game itself. The loading screen will be the only thing displayed while this load is taking place. More...

Inheritance diagram for PendulumGame.PendulumLoadingScreen:

List of all members.

Public Member Functions
override void	LoadContent ()
	Load graphics content for the game.
override void	UnloadContent ()
	Unload graphics content used by the screen.
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. The loading screen will be the only thing displayed while this load is taking place.

Definition at line 23 of file PendulumLoadingScreen.cs.

---

Member Function Documentation

override void PendulumGame.PendulumLoadingScreen.Draw

(

GameTime

gameTime

)

[virtual]

Draws the loading screen.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 125 of file PendulumLoadingScreen.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 PendulumGame.PendulumLoadingScreen.Load	(	ScreenManager	screenManager,
		bool	loadingIsSlow,
		PlayerIndex?	controllingPlayer,
		params GameScreen[]	screensToLoad
	)			[static]

Activates the loading screen.

Definition at line 70 of file PendulumLoadingScreen.cs.

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

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

            screenManager.AddScreen(loadingScreen, controllingPlayer);
        }

override void PendulumGame.PendulumLoadingScreen.LoadContent

(

)

[virtual]

Load graphics content for the game.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 54 of file PendulumLoadingScreen.cs.

        {
            // Reset game time
            ScreenManager.Game.ResetElapsedTime();
        }

override void PendulumGame.PendulumLoadingScreen.UnloadContent

(

)

[virtual]

Unload graphics content used by the screen.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 63 of file PendulumLoadingScreen.cs.

        {
        }

override void PendulumGame.PendulumLoadingScreen.Update	(	GameTime	gameTime,
		bool	otherScreenHasFocus,
		bool	coveredByOtherScreen
	)			[virtual]

Updates the loading screen.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 96 of file PendulumLoadingScreen.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, null);
                    }
                }

                // 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/PendulumGame/Screens/PendulumLoadingScreen.cs