330 lines
11 KiB
C#
330 lines
11 KiB
C#
#region File Description
|
|
//-----------------------------------------------------------------------------
|
|
// MenuScreen.cs
|
|
//
|
|
// XNA Community Game Platform
|
|
// Copyright (C) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
#endregion
|
|
|
|
#region Using Statements
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using Microsoft.Xna.Framework.Input.Touch;
|
|
using Microsoft.Xna.Framework.Input;
|
|
using FarseerPhysics.SamplesFramework;
|
|
#endregion
|
|
|
|
namespace GameStateManagement
|
|
{
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
public class MenuScreen : GameScreen
|
|
{
|
|
#region Fields
|
|
|
|
// the number of pixels to pad above and below menu entries for touch input
|
|
const int menuEntryPadding = 10;
|
|
|
|
private List<MenuEntry> menuEntries = new List<MenuEntry>();
|
|
int selectedEntry = 0;
|
|
string menuTitle;
|
|
|
|
InputAction menuUp;
|
|
InputAction menuDown;
|
|
InputAction menuSelect;
|
|
InputAction menuCancel;
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
|
|
/// <summary>
|
|
/// Gets the list of menu entries, so derived classes can add
|
|
/// or change the menu contents.
|
|
/// </summary>
|
|
protected IList<MenuEntry> MenuEntries
|
|
{
|
|
get { return menuEntries; }
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Initialization
|
|
|
|
|
|
/// <summary>
|
|
/// Constructor.
|
|
/// </summary>
|
|
public MenuScreen(string menuTitle)
|
|
{
|
|
this.menuTitle = menuTitle;
|
|
// menus generally only need Tap for menu selection
|
|
EnabledGestures = GestureType.Tap;
|
|
|
|
TransitionOnTime = TimeSpan.FromSeconds(0.5);
|
|
TransitionOffTime = TimeSpan.FromSeconds(0.5);
|
|
|
|
menuUp = new InputAction(
|
|
new Buttons[] { Buttons.DPadUp, Buttons.LeftThumbstickUp },
|
|
new Keys[] { Keys.Up },
|
|
true);
|
|
menuDown = new InputAction(
|
|
new Buttons[] { Buttons.DPadDown, Buttons.LeftThumbstickDown },
|
|
new Keys[] { Keys.Down },
|
|
true);
|
|
menuSelect = new InputAction(
|
|
new Buttons[] { Buttons.A, Buttons.Start },
|
|
new Keys[] { Keys.Enter, Keys.Space },
|
|
true);
|
|
menuCancel = new InputAction(
|
|
new Buttons[] { Buttons.B, Buttons.Back },
|
|
new Keys[] { Keys.Escape },
|
|
true);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
public void AddMenuItem(string name)
|
|
{
|
|
|
|
menuEntries.Add(new MenuEntry(name));
|
|
}
|
|
|
|
#region Handle Input
|
|
|
|
/// <summary>
|
|
/// Allows the screen to create the hit bounds for a particular menu entry.
|
|
/// </summary>
|
|
protected virtual Rectangle GetMenuEntryHitBounds(MenuEntry entry)
|
|
{
|
|
// the hit bounds are the entire width of the screen, and the height of the entry
|
|
// with some additional padding above and below.
|
|
return new Rectangle(
|
|
0,
|
|
(int)entry.Position.Y - menuEntryPadding,
|
|
ScreenManager.GraphicsDevice.Viewport.Width,
|
|
entry.GetHeight(this) + (menuEntryPadding * 2));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Responds to user input, changing the selected entry and accepting
|
|
/// or cancelling the menu.
|
|
/// </summary>
|
|
public override void HandleInput(GameTime gameTime, InputState input)
|
|
{
|
|
// For input tests 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.
|
|
|
|
|
|
#if WINDOWS || XBOX360
|
|
PlayerIndex playerIndex;
|
|
// Move to the previous menu entry?
|
|
if (menuUp.Evaluate(input, ControllingPlayer, out playerIndex))
|
|
{
|
|
selectedEntry--;
|
|
|
|
if (selectedEntry < 0)
|
|
selectedEntry = menuEntries.Count - 1;
|
|
}
|
|
|
|
// Move to the next menu entry?
|
|
if (menuDown.Evaluate(input, ControllingPlayer, out playerIndex))
|
|
{
|
|
selectedEntry++;
|
|
|
|
if (selectedEntry >= menuEntries.Count)
|
|
selectedEntry = 0;
|
|
}
|
|
|
|
if (menuSelect.Evaluate(input, ControllingPlayer, out playerIndex))
|
|
{
|
|
OnSelectEntry(selectedEntry, playerIndex);
|
|
}
|
|
else if (menuCancel.Evaluate(input, ControllingPlayer, out playerIndex))
|
|
{
|
|
OnCancel(playerIndex);
|
|
}
|
|
#endif
|
|
|
|
#if WINDOWS_PHONE
|
|
//selectedEntry = 1;
|
|
|
|
PlayerIndex player;
|
|
if (input.IsNewButtonPress(Buttons.Back, ControllingPlayer, out player))
|
|
{
|
|
OnCancel(player);
|
|
}
|
|
|
|
// look for any taps that occurred and select any entries that were tapped
|
|
foreach (GestureSample gesture in input.Gestures)
|
|
{
|
|
//System.Diagnostics.Debugger.Break();
|
|
if (gesture.GestureType == GestureType.Tap)
|
|
{
|
|
// convert the position to a Point that we can test against a Rectangle
|
|
Point tapLocation = new Point((int)gesture.Position.X, (int)gesture.Position.Y);
|
|
|
|
// iterate the entries to see if any were tapped
|
|
for (int i = 0; i < menuEntries.Count; i++)
|
|
{
|
|
MenuEntry menuEntry = menuEntries[i];
|
|
|
|
if (GetMenuEntryHitBounds(menuEntry).Contains(tapLocation))
|
|
{
|
|
// select the entry. since gestures are only available on Windows Phone,
|
|
// we can safely pass PlayerIndex.One to all entries since there is only
|
|
// one player on Windows Phone.
|
|
OnSelectEntry(i, PlayerIndex.One);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Handler for when the user has chosen a menu entry.
|
|
/// </summary>
|
|
protected virtual void OnSelectEntry(int entryIndex, PlayerIndex playerIndex)
|
|
{
|
|
menuEntries[entryIndex].OnSelectEntry(playerIndex);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Handler for when the user has cancelled the menu.
|
|
/// </summary>
|
|
protected virtual void OnCancel(PlayerIndex playerIndex)
|
|
{
|
|
ExitScreen();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Helper overload makes it easy to use OnCancel as a MenuEntry event handler.
|
|
/// </summary>
|
|
protected void OnCancel(object sender, PlayerIndexEventArgs e)
|
|
{
|
|
OnCancel(e.PlayerIndex);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Update and Draw
|
|
|
|
|
|
/// <summary>
|
|
/// Allows the screen the chance to position the menu entries. By default
|
|
/// all menu entries are lined up in a vertical list, centered on the screen.
|
|
/// </summary>
|
|
protected virtual void UpdateMenuEntryLocations()
|
|
{
|
|
// 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);
|
|
|
|
// start at Y = 175; each X value is generated per entry
|
|
Vector2 position = new Vector2(0f, 175f);
|
|
|
|
// update each menu entry's location in turn
|
|
for (int i = 0; i < menuEntries.Count; i++)
|
|
{
|
|
MenuEntry menuEntry = menuEntries[i];
|
|
|
|
// each entry is to be centered horizontally
|
|
position.X = ScreenManager.GraphicsDevice.Viewport.Width / 2 - menuEntry.GetWidth(this) / 2;
|
|
|
|
if (ScreenState == ScreenState.TransitionOn)
|
|
position.X -= transitionOffset * 256;
|
|
else
|
|
position.X += transitionOffset * 512;
|
|
|
|
// set the entry's position
|
|
menuEntry.Position = position;
|
|
|
|
// move down for the next entry the size of this entry
|
|
position.Y += menuEntry.GetHeight(this);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Updates the menu.
|
|
/// </summary>
|
|
public override void Update(GameTime gameTime, bool otherScreenHasFocus,
|
|
bool coveredByOtherScreen)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Draws the menu.
|
|
/// </summary>
|
|
public override void Draw(GameTime gameTime)
|
|
{
|
|
// make sure our entries are in the right place before we draw them
|
|
UpdateMenuEntryLocations();
|
|
|
|
GraphicsDevice graphics = ScreenManager.GraphicsDevice;
|
|
SpriteBatch spriteBatch = ScreenManager.SpriteBatch;
|
|
SpriteFont font = ScreenManager.Font;
|
|
|
|
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, isSelected, gameTime);
|
|
}
|
|
|
|
// 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);
|
|
|
|
// Draw the menu title centered on the screen
|
|
Vector2 titlePosition = new Vector2(graphics.Viewport.Width / 2, 80);
|
|
Vector2 titleOrigin = font.MeasureString(menuTitle) / 2;
|
|
Color titleColor = new Color(192, 192, 192) * TransitionAlpha;
|
|
float titleScale = 1.25f;
|
|
|
|
titlePosition.Y -= transitionOffset * 100;
|
|
|
|
spriteBatch.DrawString(font, menuTitle, titlePosition, titleColor, 0,
|
|
titleOrigin, titleScale, SpriteEffects.None, 0);
|
|
|
|
spriteBatch.End();
|
|
}
|
|
|
|
|
|
#endregion
|
|
}
|
|
}
|