NewGamePhysics.StateManager.MenuScreen Class Reference

Base class for screens that contain a menu of options. The user can move up and down to select an entry, or cancel to back out of the screen. More...

Inheritance diagram for NewGamePhysics.StateManager.MenuScreen:

List of all members.

Public Member Functions
	MenuScreen (string menuTitle)
	Constructor.
override void	HandleInput (InputState input)
	Responds to user input, changing the selected entry and accepting or cancelling the menu.
override void	Update (GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
	Updates the menu.
override void	Draw (GameTime gameTime)
	Draws the menu.
Protected Member Functions
virtual void	OnSelectEntry (int entryIndex, PlayerIndex playerIndex)
	Handler for when the user has chosen a menu entry.
virtual void	OnCancel (PlayerIndex playerIndex)
	Handler for when the user has cancelled the menu.
void	OnCancel (object sender, PlayerIndexEventArgs e)
	Helper overload makes it easy to use OnCancel as a MenuEntry event handler.
Properties
IList< MenuEntry >	MenuEntries [get]
	Gets the list of menu entries, so derived classes can add or change the menu contents.
int	SelectedEntry [get, set]
	Gets or sets the currently selected menu entry.
bool	WaitForUncover [get, set]
	Gets the list of menu entries, so derived classes can add or change the menu contents.

---

Detailed Description

Base class for screens that contain a menu of options. The user can move up and down to select an entry, or cancel to back out of the screen.

Definition at line 18 of file MenuScreen.cs.

---

Constructor & Destructor Documentation

NewGamePhysics.StateManager.MenuScreen.MenuScreen

(

string

menuTitle

)

Constructor.

Definition at line 86 of file MenuScreen.cs.

        {
            this.menuTitle = menuTitle;

            TransitionOnTime = TimeSpan.FromSeconds(0.5);
            TransitionOffTime = TimeSpan.FromSeconds(0.5);
        }

---

Member Function Documentation

override void NewGamePhysics.StateManager.MenuScreen.Draw

(

GameTime

gameTime

)

[virtual]

Draws the menu.

Parameters:

gameTime

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Reimplemented in GravityChooser.GravityChooserMainMenuScreen, GravityChooser.GravityChooserOptionsMenuScreen, GravityChooser.GravityChooserPauseMenuScreen, MontyHallGame.MontyHallGameOverScreen, MontyHallGame.MontyHallMainMenuScreen, MontyHallGame.MontyHallOptionsMenuScreen, MontyHallGame.MontyHallPauseMenuScreen, PendulumGame.PendulumGameOverScreen, PendulumGame.PendulumOptionsMenuScreen, and PendulumGame.PendulumPauseMenuScreen.

Definition at line 196 of file MenuScreen.cs.

        {
            SpriteBatch spriteBatch = ScreenManager.SpriteBatch;
            SpriteFont font = ScreenManager.Fonts["menu"];
            Viewport viewport = ScreenManager.GraphicsDevice.Viewport;

            // Measure size of menu stack
            float menuSize = 0.0f;
            for (int i = 0; i < menuEntries.Count; i++)
            {
                MenuEntry menuEntry = menuEntries[i];
                menuSize += (menuEntry.GetHeight(this) + 5);
            }

            // Center menu vertically
            Vector2 position = new Vector2(
                viewport.Width / 2 - 200, 
                (viewport.Height - menuSize) / 2);

            // Make the menu slide into place during transitions, using a
            // power curve to make things look more interesting (this makes
            // the movement slow down as it nears the end).
            float transitionOffset = (float)Math.Pow(TransitionPosition, 2);

            if (ScreenState == ScreenState.TransitionOn)
            {
                position.X -= transitionOffset * 256;
            }
            else
            {
                position.X += transitionOffset * 512;
            }

            spriteBatch.Begin();

            // Draw each menu entry in turn.
            for (int i = 0; i < menuEntries.Count; i++)
            {
                MenuEntry menuEntry = menuEntries[i];

                bool isSelected = IsActive && (i == selectedEntry);

                menuEntry.Draw(this, position, isSelected, gameTime);
                

                position.Y += (menuEntry.GetHeight(this) + 5);
            }

            // Create translucent pane rectangle 
            if (this.paneTexture == null)
            {
                // New background texture
                this.paneTexture = TextureHelpers.Create(ScreenManager.GraphicsDevice, new Color(64, 64, 64));
            }

            // Draw the menu title.
            float titleScale = 1.5f;
            Vector2 titlePosition = new Vector2(position.X, viewport.Height/2);
            Vector2 titleSize = font.MeasureString(menuTitle);
            Vector2 titleOrigin = titleSize / 2;
            Color titleColor = new Color(255, 255, 255, TransitionAlpha);
            titlePosition.X -= titleSize.Y * titleScale;
            titlePosition.Y -= transitionOffset * 100;
            Color paneColor = new Color(4, 4, 4);
            Rectangle backgroundPane =
                new Rectangle(
                    (int)(titlePosition.X - titleOrigin.Y), 0, (int)titleSize.Y, viewport.Height);
            spriteBatch.Draw(this.paneTexture, backgroundPane, new Color(paneColor, 128));

            spriteBatch.DrawString(font, menuTitle, titlePosition, titleColor, 3.0f*(float)Math.PI/2.0f,
                                   titleOrigin, titleScale, SpriteEffects.None, 0);

            spriteBatch.End();
        }

override void NewGamePhysics.StateManager.MenuScreen.HandleInput

(

InputState

input

)

[virtual]

Responds to user input, changing the selected entry and accepting or cancelling the menu.

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Definition at line 102 of file MenuScreen.cs.

        {
            // Move to the previous menu entry?
            if (input.IsNewInputUp(ControllingPlayer))
            {
                this.selectedEntry--;

                if (this.selectedEntry < 0)
                {
                    this.selectedEntry = this.menuEntries.Count - 1;
                }
            }

            // Move to the next menu entry?
            if (input.IsNewInputDown(ControllingPlayer))
            {
                this.selectedEntry++;

                if (this.selectedEntry >= this.menuEntries.Count)
                {
                    this.selectedEntry = 0;
                }
            }

            // Accept or cancel the menu? We pass in our ControllingPlayer, which may
            // either be null (to accept input from any player) or a specific index.
            // If we pass a null controlling player, the InputState helper returns to
            // us which player actually provided the input. We pass that through to
            // OnSelectEntry and OnCancel, so they can tell which player triggered them.
            PlayerIndex playerIndex;

            if (input.IsMenuSelect(ControllingPlayer, out playerIndex))
            {
                OnSelectEntry(this.selectedEntry, playerIndex);
            }
            else if (input.IsMenuCancel(ControllingPlayer, out playerIndex))
            {
                OnCancel(playerIndex);
            }
        }

void NewGamePhysics.StateManager.MenuScreen.OnCancel	(	object	sender,
		PlayerIndexEventArgs	e
	)			[protected]

Helper overload makes it easy to use OnCancel as a MenuEntry event handler.

Definition at line 162 of file MenuScreen.cs.

        {
            OnCancel(e.PlayerIndex);
        }

virtual void NewGamePhysics.StateManager.MenuScreen.OnCancel

(

PlayerIndex

playerIndex

)

[protected, virtual]

Handler for when the user has cancelled the menu.

Reimplemented in GravityChooser.GravityChooserMainMenuScreen, MontyHallGame.MontyHallMainMenuScreen, and PendulumGame.PendulumMainMenuScreen.

Definition at line 154 of file MenuScreen.cs.

        {
            ExitScreen();
        }

virtual void NewGamePhysics.StateManager.MenuScreen.OnSelectEntry	(	int	entryIndex,
		PlayerIndex	playerIndex
	)			[protected, virtual]

Handler for when the user has chosen a menu entry.

Definition at line 146 of file MenuScreen.cs.

        {
            menuEntries[this.selectedEntry].OnSelectEntry(playerIndex);
        }

override void NewGamePhysics.StateManager.MenuScreen.Update	(	GameTime	gameTime,
		bool	otherScreenHasFocus,
		bool	coveredByOtherScreen
	)			[virtual]

Updates the menu.

Parameters:

	gameTime
	coveredByOtherScreen
	otherScreenHasFocus

Reimplemented from NewGamePhysics.StateManager.GameScreen.

Reimplemented in GravityChooser.GravityChooserMainMenuScreen, GravityChooser.GravityChooserOptionsMenuScreen, MontyHallGame.MontyHallMainMenuScreen, MontyHallGame.MontyHallOptionsMenuScreen, PendulumGame.PendulumGameOverScreen, and PendulumGame.PendulumOptionsMenuScreen.

Definition at line 177 of file MenuScreen.cs.

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

            // Update each nested MenuEntry object.
            for (int i = 0; i < menuEntries.Count; i++)
            {
                bool isSelected = IsActive && (i == selectedEntry);

                menuEntries[i].Update(this, isSelected, gameTime);
            }
        }

---

Property Documentation

IList<MenuEntry> NewGamePhysics.StateManager.MenuScreen.MenuEntries [get, protected]

Gets the list of menu entries, so derived classes can add or change the menu contents.

Definition at line 56 of file MenuScreen.cs.

int NewGamePhysics.StateManager.MenuScreen.SelectedEntry [get, set]

Gets or sets the currently selected menu entry.

Definition at line 64 of file MenuScreen.cs.

bool NewGamePhysics.StateManager.MenuScreen.WaitForUncover [get, set, protected]

Gets the list of menu entries, so derived classes can add or change the menu contents.

Definition at line 74 of file MenuScreen.cs.

---

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

• C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/StateManager/MenuScreen.cs