From 4057123b6e00212e0ecb590cffbe424bcb2f8a1c Mon Sep 17 00:00:00 2001 From: "nathan@daedalus" Date: Thu, 12 Apr 2012 22:09:49 -0500 Subject: [PATCH 1/7] Branching starting code for the new GSM --HG-- branch : axios-newgsm --- axios/Axios_WP7.csproj | 14 + axios/Axios_Windows.csproj | 14 + axios/Axios_Windows.csproj.user | 2 +- axios/Axios_Xbox_360.csproj | 14 + axios/Engine/AxiosGameScreen.cs | 17 +- axios/ScreenSystem/BackgroundScreen.cs | 104 +++-- .../ScreenSystem/FramerateCounterComponent.cs | 1 + axios/ScreenSystem/GameScreen.cs | 226 ++++++---- axios/ScreenSystem/InputHelper.cs | 1 + axios/ScreenSystem/LogoScreen.cs | 37 +- axios/ScreenSystem/MenuButton.cs | 2 +- axios/ScreenSystem/MenuEntry.cs | 211 +++++---- axios/ScreenSystem/MenuScreen.cs | 406 +++++++----------- axios/ScreenSystem/MessageBoxScreen.cs | 173 ++++++-- axios/ScreenSystem/PhysicsGameScreen.cs | 107 ++--- axios/ScreenSystem/ScreenManagerComponent.cs | 6 +- 16 files changed, 758 insertions(+), 577 deletions(-) diff --git a/axios/Axios_WP7.csproj b/axios/Axios_WP7.csproj index 45f9c86..d5658bf 100644 --- a/axios/Axios_WP7.csproj +++ b/axios/Axios_WP7.csproj @@ -190,18 +190,32 @@ + + + + + + + + + + + + + + diff --git a/axios/Axios_Windows.csproj b/axios/Axios_Windows.csproj index 1b76ffe..2c73e8c 100644 --- a/axios/Axios_Windows.csproj +++ b/axios/Axios_Windows.csproj @@ -234,19 +234,33 @@ + + + + + + + + + + + + + + diff --git a/axios/Axios_Windows.csproj.user b/axios/Axios_Windows.csproj.user index 76fe5a5..566c009 100644 --- a/axios/Axios_Windows.csproj.user +++ b/axios/Axios_Windows.csproj.user @@ -1,6 +1,6 @@  - ProjectFiles + ShowAllFiles \ No newline at end of file diff --git a/axios/Axios_Xbox_360.csproj b/axios/Axios_Xbox_360.csproj index f15b1d4..7c073c9 100644 --- a/axios/Axios_Xbox_360.csproj +++ b/axios/Axios_Xbox_360.csproj @@ -183,18 +183,32 @@ + + + + + + + + + + + + + + diff --git a/axios/Engine/AxiosGameScreen.cs b/axios/Engine/AxiosGameScreen.cs index ece11f8..a487746 100644 --- a/axios/Engine/AxiosGameScreen.cs +++ b/axios/Engine/AxiosGameScreen.cs @@ -8,7 +8,9 @@ using Axios.Engine.UI; using FarseerPhysics.Dynamics; using FarseerPhysics.SamplesFramework; using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Content; using Microsoft.Xna.Framework.Graphics; +using GameStateManagement; namespace Axios.Engine { @@ -158,19 +160,16 @@ namespace Axios.Engine AxiosLog.Instance.AddLine("Memory usage after cleanup: ", LoggingFlag.DEBUG); } - public override void ExitScreen() + public override void Activate(bool instancePreserved) { - base.ExitScreen(); - - } - - public override void LoadContent() - { - base.LoadContent(); + base.Activate(instancePreserved); #if DEBUG if (!Axios.Settings.ScreenSaver) - this.DebugSpriteFont = this.ScreenManager.Content.Load(this.DebugTextFont); + { + ContentManager man = new ContentManager(ScreenManager.Game.Services, "Content"); + this.DebugSpriteFont = man.Load(this.DebugTextFont); + } #endif } diff --git a/axios/ScreenSystem/BackgroundScreen.cs b/axios/ScreenSystem/BackgroundScreen.cs index f4903a6..e3df4d5 100644 --- a/axios/ScreenSystem/BackgroundScreen.cs +++ b/axios/ScreenSystem/BackgroundScreen.cs @@ -1,24 +1,38 @@ -using System; -using Microsoft.Xna.Framework; -using Microsoft.Xna.Framework.Graphics; +#region File Description +//----------------------------------------------------------------------------- +// BackgroundScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion -namespace FarseerPhysics.SamplesFramework +#region Using Statements +using System; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.Graphics; +using GameStateManagement; +#endregion + +namespace GameStateManagement { /// /// The background screen sits behind all the other menu screens. /// It draws a background image that remains fixed in place regardless /// of whatever transitions the screens on top of it may be doing. /// - public class BackgroundScreen : GameScreen + class BackgroundScreen : GameScreen { - private const float LogoScreenHeightRatio = 0.25f; - private const float LogoScreenBorderRatio = 0.0375f; - private const float LogoWidthHeightRatio = 1.4f; + #region Fields + + ContentManager content; + Texture2D backgroundTexture; + + #endregion + + #region Initialization - private Texture2D _backgroundTexture; - private Rectangle _logoDestination; - //private Texture2D _logoTexture; - private Rectangle _viewport; /// /// Constructor. @@ -29,24 +43,40 @@ namespace FarseerPhysics.SamplesFramework TransitionOffTime = TimeSpan.FromSeconds(0.5); } - public override void LoadContent() + + /// + /// Loads graphics content for this screen. The background texture is quite + /// big, so we use our own local ContentManager to load it. This allows us + /// to unload before going from the menus into the game itself, wheras if we + /// used the shared ContentManager provided by the Game class, the content + /// would remain loaded forever. + /// + public override void Activate(bool instancePreserved) { - //_logoTexture = ScreenManager.Content.Load("Common/logo"); - _backgroundTexture = ScreenManager.Content.Load("Common/gradient"); + if (!instancePreserved) + { + if (content == null) + content = new ContentManager(ScreenManager.Game.Services, "Content"); - Viewport viewport = ScreenManager.GraphicsDevice.Viewport; - Vector2 logoSize = new Vector2(); - logoSize.Y = viewport.Height * LogoScreenHeightRatio; - logoSize.X = logoSize.Y * LogoWidthHeightRatio; - - float border = viewport.Height * LogoScreenBorderRatio; - Vector2 logoPosition = new Vector2(viewport.Width - border - logoSize.X, - viewport.Height - border - logoSize.Y); - _logoDestination = new Rectangle((int)logoPosition.X, (int)logoPosition.Y, (int)logoSize.X, - (int)logoSize.Y); - _viewport = viewport.Bounds; + backgroundTexture = content.Load("background"); + } } + + /// + /// Unloads graphics content for this screen. + /// + public override void Unload() + { + content.Unload(); + } + + + #endregion + + #region Update and Draw + + /// /// Updates the background screen. Unlike most screens, this should not /// transition off even if it has been covered by another screen: it is @@ -55,20 +85,30 @@ namespace FarseerPhysics.SamplesFramework /// Update method wanting to transition off. /// public override void Update(GameTime gameTime, bool otherScreenHasFocus, - bool coveredByOtherScreen) + bool coveredByOtherScreen) { base.Update(gameTime, otherScreenHasFocus, false); } + /// /// Draws the background screen. /// public override void Draw(GameTime gameTime) { - ScreenManager.SpriteBatch.Begin(); - ScreenManager.SpriteBatch.Draw(_backgroundTexture, _viewport, Color.White); - //ScreenManager.SpriteBatch.Draw(_logoTexture, _logoDestination, Color.White * 0.6f); - ScreenManager.SpriteBatch.End(); + SpriteBatch spriteBatch = ScreenManager.SpriteBatch; + Viewport viewport = ScreenManager.GraphicsDevice.Viewport; + Rectangle fullscreen = new Rectangle(0, 0, viewport.Width, viewport.Height); + + spriteBatch.Begin(); + + spriteBatch.Draw(backgroundTexture, fullscreen, + new Color(TransitionAlpha, TransitionAlpha, TransitionAlpha)); + + spriteBatch.End(); } + + + #endregion } -} \ No newline at end of file +} diff --git a/axios/ScreenSystem/FramerateCounterComponent.cs b/axios/ScreenSystem/FramerateCounterComponent.cs index da8b0a0..cf8803e 100644 --- a/axios/ScreenSystem/FramerateCounterComponent.cs +++ b/axios/ScreenSystem/FramerateCounterComponent.cs @@ -1,6 +1,7 @@ using System; using System.Globalization; using Microsoft.Xna.Framework; +using GameStateManagement; namespace FarseerPhysics.SamplesFramework { diff --git a/axios/ScreenSystem/GameScreen.cs b/axios/ScreenSystem/GameScreen.cs index 68281cc..5319df2 100644 --- a/axios/ScreenSystem/GameScreen.cs +++ b/axios/ScreenSystem/GameScreen.cs @@ -1,19 +1,18 @@ #region File Description - //----------------------------------------------------------------------------- -// PlayerIndexEventArgs.cs +// GameScreen.cs // -// XNA Community Game Platform +// Microsoft XNA Community Game Platform // Copyright (C) Microsoft Corporation. All rights reserved. //----------------------------------------------------------------------------- - #endregion using System; +using System.IO; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Input.Touch; -namespace FarseerPhysics.SamplesFramework +namespace GameStateManagement { /// /// Enum describes the screen transition state. @@ -26,6 +25,7 @@ namespace FarseerPhysics.SamplesFramework Hidden, } + /// /// A screen is a single layer that has update and draw logic, and which /// can be combined with other layers to build up a complex menu system. @@ -35,23 +35,6 @@ namespace FarseerPhysics.SamplesFramework /// public abstract class GameScreen { - private GestureType _enabledGestures = GestureType.None; - private bool _otherScreenHasFocus; - - public GameScreen() - { - ScreenState = ScreenState.TransitionOn; - TransitionPosition = 1; - TransitionOffTime = TimeSpan.Zero; - TransitionOnTime = TimeSpan.Zero; - HasCursor = false; - HasVirtualStick = false; - } - - public bool HasCursor { get; set; } - - public bool HasVirtualStick { get; set; } - /// /// Normally when one screen is brought up over the top of another, /// the first screen will transition off to make room for the new @@ -59,26 +42,54 @@ namespace FarseerPhysics.SamplesFramework /// popup, in which case screens underneath it do not need to bother /// transitioning off. /// - public bool IsPopup { get; protected set; } + public bool IsPopup + { + get { return isPopup; } + protected set { isPopup = value; } + } + + bool isPopup = false; + /// /// Indicates how long the screen takes to /// transition on when it is activated. /// - public TimeSpan TransitionOnTime { get; protected set; } + public TimeSpan TransitionOnTime + { + get { return transitionOnTime; } + protected set { transitionOnTime = value; } + } + + TimeSpan transitionOnTime = TimeSpan.Zero; + /// /// Indicates how long the screen takes to /// transition off when it is deactivated. /// - public TimeSpan TransitionOffTime { get; protected set; } + public TimeSpan TransitionOffTime + { + get { return transitionOffTime; } + protected set { transitionOffTime = value; } + } + + TimeSpan transitionOffTime = TimeSpan.Zero; + /// /// Gets the current position of the screen transition, ranging /// from zero (fully active, no transition) to one (transitioned /// fully off to nothing). /// - public float TransitionPosition { get; protected set; } + public float TransitionPosition + { + get { return transitionPosition; } + protected set { transitionPosition = value; } + } + + float transitionPosition = 1; + /// /// Gets the current alpha of the screen transition, ranging @@ -90,10 +101,18 @@ namespace FarseerPhysics.SamplesFramework get { return 1f - TransitionPosition; } } + /// /// Gets the current screen transition state. /// - public ScreenState ScreenState { get; protected set; } + public ScreenState ScreenState + { + get { return screenState; } + protected set { screenState = value; } + } + + ScreenState screenState = ScreenState.TransitionOn; + /// /// There are two possible reasons why a screen might be transitioning @@ -103,9 +122,14 @@ namespace FarseerPhysics.SamplesFramework /// if set, the screen will automatically remove itself as soon as the /// transition finishes. /// - public bool IsExiting { get; protected internal set; } + public bool IsExiting + { + get { return isExiting; } + protected internal set { isExiting = value; } + } + + bool isExiting = false; - public bool AlwaysHasFocus = false; /// /// Checks whether this screen is active and can respond to user input. @@ -114,16 +138,43 @@ namespace FarseerPhysics.SamplesFramework { get { - return !_otherScreenHasFocus && - (ScreenState == ScreenState.TransitionOn || - ScreenState == ScreenState.Active); + return !otherScreenHasFocus && + (screenState == ScreenState.TransitionOn || + screenState == ScreenState.Active); } } + bool otherScreenHasFocus; + + /// /// Gets the manager that this screen belongs to. /// - public ScreenManager ScreenManager { get; internal set; } + public ScreenManager ScreenManager + { + get { return screenManager; } + internal set { screenManager = value; } + } + + ScreenManager screenManager; + + + /// + /// Gets the index of the player who is currently controlling this screen, + /// or null if it is accepting input from any player. This is used to lock + /// the game to a specific player profile. The main menu responds to input + /// from any connected gamepad, but whichever player makes a selection from + /// this menu is given control over all subsequent screens, so other gamepads + /// are inactive until the controlling player returns to the main menu. + /// + public PlayerIndex? ControllingPlayer + { + get { return controllingPlayer; } + internal set { controllingPlayer = value; } + } + + PlayerIndex? controllingPlayer; + /// /// Gets the gestures the screen is interested in. Screens should be as specific @@ -134,10 +185,10 @@ namespace FarseerPhysics.SamplesFramework /// public GestureType EnabledGestures { - get { return _enabledGestures; } + get { return enabledGestures; } protected set { - _enabledGestures = value; + enabledGestures = value; // the screen manager handles this during screen changes, but // if this screen is active and the gesture types are changing, @@ -149,36 +200,62 @@ namespace FarseerPhysics.SamplesFramework } } - /// - /// Load graphics content for the screen. - /// - public virtual void LoadContent() - { - } + GestureType enabledGestures = GestureType.None; /// - /// Unload content for the screen. + /// Gets whether or not this screen is serializable. If this is true, + /// the screen will be recorded into the screen manager's state and + /// its Serialize and Deserialize methods will be called as appropriate. + /// If this is false, the screen will be ignored during serialization. + /// By default, all screens are assumed to be serializable. /// - public virtual void UnloadContent() + public bool IsSerializable { + get { return isSerializable; } + protected set { isSerializable = value; } } + bool isSerializable = true; + + + /// + /// Activates the screen. Called when the screen is added to the screen manager or if the game resumes + /// from being paused or tombstoned. + /// + /// + /// True if the game was preserved during deactivation, false if the screen is just being added or if the game was tombstoned. + /// On Xbox and Windows this will always be false. + /// + public virtual void Activate(bool instancePreserved) { } + + + /// + /// Deactivates the screen. Called when the game is being deactivated due to pausing or tombstoning. + /// + public virtual void Deactivate() { } + + + /// + /// Unload content for the screen. Called when the screen is removed from the screen manager. + /// + public virtual void Unload() { } + + /// /// Allows the screen to run logic, such as updating the transition position. /// Unlike HandleInput, this method is called regardless of whether the screen /// is active, hidden, or in the middle of a transition. /// - public virtual void Update(GameTime gameTime, bool otherScreenHasFocus, - bool coveredByOtherScreen) + public virtual void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen) { - _otherScreenHasFocus = otherScreenHasFocus; + this.otherScreenHasFocus = otherScreenHasFocus; - if (IsExiting) + if (isExiting) { // If the screen is going away to die, it should transition off. - ScreenState = ScreenState.TransitionOff; + screenState = ScreenState.TransitionOff; - if (!UpdateTransition(gameTime, TransitionOffTime, 1)) + if (!UpdateTransition(gameTime, transitionOffTime, 1)) { // When the transition finishes, remove the screen. ScreenManager.RemoveScreen(this); @@ -187,59 +264,55 @@ namespace FarseerPhysics.SamplesFramework else if (coveredByOtherScreen) { // If the screen is covered by another, it should transition off. - if (UpdateTransition(gameTime, TransitionOffTime, 1)) + if (UpdateTransition(gameTime, transitionOffTime, 1)) { // Still busy transitioning. - ScreenState = ScreenState.TransitionOff; + screenState = ScreenState.TransitionOff; } else { // Transition finished! - ScreenState = ScreenState.Hidden; + screenState = ScreenState.Hidden; } } else { // Otherwise the screen should transition on and become active. - if (UpdateTransition(gameTime, TransitionOnTime, -1)) + if (UpdateTransition(gameTime, transitionOnTime, -1)) { // Still busy transitioning. - ScreenState = ScreenState.TransitionOn; + screenState = ScreenState.TransitionOn; } else { // Transition finished! - ScreenState = ScreenState.Active; + screenState = ScreenState.Active; } } } + /// /// Helper for updating the screen transition position. /// - private bool UpdateTransition(GameTime gameTime, TimeSpan time, int direction) + bool UpdateTransition(GameTime gameTime, TimeSpan time, int direction) { // How much should we move by? float transitionDelta; if (time == TimeSpan.Zero) - { - transitionDelta = 1f; - } + transitionDelta = 1; else - { - transitionDelta = (float)(gameTime.ElapsedGameTime.TotalMilliseconds / - time.TotalMilliseconds); - } + transitionDelta = (float)(gameTime.ElapsedGameTime.TotalMilliseconds / time.TotalMilliseconds); // Update the transition position. - TransitionPosition += transitionDelta * direction; + transitionPosition += transitionDelta * direction; // Did we reach the end of the transition? - if (((direction < 0) && (TransitionPosition <= 0)) || - ((direction > 0) && (TransitionPosition >= 1))) + if (((direction < 0) && (transitionPosition <= 0)) || + ((direction > 0) && (transitionPosition >= 1))) { - TransitionPosition = MathHelper.Clamp(TransitionPosition, 0, 1); + transitionPosition = MathHelper.Clamp(transitionPosition, 0, 1); return false; } @@ -247,30 +320,29 @@ namespace FarseerPhysics.SamplesFramework return true; } + /// /// Allows the screen to handle user input. Unlike Update, this method /// is only called when the screen is active, and not when some other /// screen has taken the focus. /// - public virtual void HandleInput(InputHelper input, GameTime gameTime) - { - } + public virtual void HandleInput(GameTime gameTime, InputState input) { } + /// /// This is called when the screen should draw itself. /// - public virtual void Draw(GameTime gameTime) - { - } + public virtual void Draw(GameTime gameTime) { } + /// /// Tells the screen to go away. Unlike ScreenManager.RemoveScreen, which /// instantly kills the screen, this method respects the transition timings /// and will give the screen a chance to gradually transition off. /// - public virtual void ExitScreen() + public void ExitScreen() { - if (TransitionOffTime == TimeSpan.Zero && this.TransitionPosition == 0 && this.TransitionAlpha == 1) + if (TransitionOffTime == TimeSpan.Zero) { // If the screen has a zero transition time, remove it immediately. ScreenManager.RemoveScreen(this); @@ -278,8 +350,8 @@ namespace FarseerPhysics.SamplesFramework else { // Otherwise flag that it should transition off and then exit. - IsExiting = true; + isExiting = true; } } } -} \ No newline at end of file +} diff --git a/axios/ScreenSystem/InputHelper.cs b/axios/ScreenSystem/InputHelper.cs index c3d4e1c..0703add 100644 --- a/axios/ScreenSystem/InputHelper.cs +++ b/axios/ScreenSystem/InputHelper.cs @@ -3,6 +3,7 @@ using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Graphics; using Microsoft.Xna.Framework.Input; using Microsoft.Xna.Framework.Input.Touch; +using GameStateManagement; namespace FarseerPhysics.SamplesFramework { diff --git a/axios/ScreenSystem/LogoScreen.cs b/axios/ScreenSystem/LogoScreen.cs index f78f3ec..27b1ed6 100644 --- a/axios/ScreenSystem/LogoScreen.cs +++ b/axios/ScreenSystem/LogoScreen.cs @@ -3,8 +3,9 @@ using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Content; using Microsoft.Xna.Framework.Graphics; using Microsoft.Xna.Framework.Input; +using FarseerPhysics.SamplesFramework; -namespace FarseerPhysics.SamplesFramework +namespace GameStateManagement { public class LogoScreen : GameScreen { @@ -29,34 +30,38 @@ namespace FarseerPhysics.SamplesFramework /// used the shared ContentManager provided by the Game class, the content /// would remain loaded forever. /// - public override void LoadContent() + public override void Activate(bool instancePreserved) { - if (_content == null) + if (!instancePreserved) { - _content = new ContentManager(ScreenManager.Game.Services, "Content"); + if (_content == null) + { + _content = new ContentManager(ScreenManager.Game.Services, "Content"); + } + + _farseerLogoTexture = _content.Load("Common/logo"); + + Viewport viewport = ScreenManager.GraphicsDevice.Viewport; + int rectHeight = (int)(viewport.Height * LogoScreenHeightRatio); + int rectWidth = (int)(rectHeight * LogoWidthHeightRatio); + int posX = viewport.Bounds.Center.X - rectWidth / 2; + int posY = viewport.Bounds.Center.Y - rectHeight / 2; + + _destination = new Rectangle(posX, posY, rectWidth, rectHeight); } - - _farseerLogoTexture = _content.Load("Common/logo"); - - Viewport viewport = ScreenManager.GraphicsDevice.Viewport; - int rectHeight = (int)(viewport.Height * LogoScreenHeightRatio); - int rectWidth = (int)(rectHeight * LogoWidthHeightRatio); - int posX = viewport.Bounds.Center.X - rectWidth / 2; - int posY = viewport.Bounds.Center.Y - rectHeight / 2; - - _destination = new Rectangle(posX, posY, rectWidth, rectHeight); } /// /// Unloads graphics content for this screen. /// - public override void UnloadContent() + public override void Unload() { _content.Unload(); } - public override void HandleInput(InputHelper input, GameTime gameTime) + public override void HandleInput(GameTime gameTime, InputState input) { + //input. if (input.KeyboardState.GetPressedKeys().Length > 0 || input.GamePadState.IsButtonDown(Buttons.A | Buttons.Start | Buttons.Back) || input.MouseState.LeftButton == ButtonState.Pressed) diff --git a/axios/ScreenSystem/MenuButton.cs b/axios/ScreenSystem/MenuButton.cs index 67e8df4..01d5bbe 100644 --- a/axios/ScreenSystem/MenuButton.cs +++ b/axios/ScreenSystem/MenuButton.cs @@ -2,7 +2,7 @@ using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Graphics; -namespace FarseerPhysics.SamplesFramework +namespace GameStateManagement { /// /// Helper class represents a single entry in a MenuScreen. By default this diff --git a/axios/ScreenSystem/MenuEntry.cs b/axios/ScreenSystem/MenuEntry.cs index 1f3efc2..6261fc1 100644 --- a/axios/ScreenSystem/MenuEntry.cs +++ b/axios/ScreenSystem/MenuEntry.cs @@ -1,39 +1,35 @@ -using System; +#region File Description +//----------------------------------------------------------------------------- +// MenuEntry.cs +// +// XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +#region Using Statements +using System; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Graphics; +using GameStateManagement; +#endregion -namespace FarseerPhysics.SamplesFramework +namespace GameStateManagement { - public enum EntryType - { - Screen, - Separator, - ExitItem, - BackItem - } - /// /// Helper class represents a single entry in a MenuScreen. By default this /// just draws the entry text string, but it can be customized to display menu /// entries in different ways. This also provides an event that will be raised /// when the menu entry is selected. /// - public sealed class MenuEntry + class MenuEntry { - private float _alpha; - private Vector2 _baseOrigin; - - private float _height; - private MenuScreen _menu; + #region Fields /// - /// The position at which the entry is drawn. This is set by the MenuScreen - /// each frame in Update. + /// The text rendered for this entry. /// - private Vector2 _position; - - private float _scale; - private GameScreen _screen; + string text; /// /// Tracks a fading selection effect on the entry. @@ -41,28 +37,17 @@ namespace FarseerPhysics.SamplesFramework /// /// The entries transition out of the selection effect when they are deselected. /// - private float _selectionFade; + float selectionFade; /// - /// The text rendered for this entry. + /// The position at which the entry is drawn. This is set by the MenuScreen + /// each frame in Update. /// - private string _text; + Vector2 position; - private EntryType _type; - private float _width; + #endregion - /// - /// Constructs a new menu entry with the specified text. - /// - public MenuEntry(MenuScreen menu, string text, EntryType type, GameScreen screen) - { - _text = text; - _screen = screen; - _type = type; - _menu = menu; - _scale = 0.9f; - _alpha = 1.0f; - } + #region Properties /// @@ -70,124 +55,138 @@ namespace FarseerPhysics.SamplesFramework /// public string Text { - get { return _text; } - set { _text = value; } + get { return text; } + set { text = value; } } + /// /// Gets or sets the position at which to draw this menu entry. /// public Vector2 Position { - get { return _position; } - set { _position = value; } + get { return position; } + set { position = value; } } - public float Alpha + + #endregion + + #region Events + + + /// + /// Event raised when the menu entry is selected. + /// + public event EventHandler Selected; + + + /// + /// Method for raising the Selected event. + /// + protected internal virtual void OnSelectEntry(PlayerIndex playerIndex) { - get { return _alpha; } - set { _alpha = value; } + if (Selected != null) + Selected(this, new PlayerIndexEventArgs(playerIndex)); } - public GameScreen Screen + + #endregion + + #region Initialization + + + /// + /// Constructs a new menu entry with the specified text. + /// + public MenuEntry(string text) { - get { return _screen; } + this.text = text; } - public void Initialize() - { - SpriteFont font = _menu.ScreenManager.Fonts.MenuSpriteFont; - _baseOrigin = new Vector2(font.MeasureString(Text).X, font.MeasureString("M").Y) * 0.5f; + #endregion - _width = font.MeasureString(Text).X * 0.8f; - _height = font.MeasureString("M").Y * 0.8f; - } + #region Update and Draw - public bool IsExitItem() - { - return _type == EntryType.ExitItem; - } - - public bool IsSelectable() - { - return _type != EntryType.Separator; - } - - public bool IsBackItem() - { - return _type == EntryType.BackItem; - } /// /// Updates the menu entry. /// - public void Update(bool isSelected, GameTime gameTime) + public virtual void Update(MenuScreen screen, bool isSelected, GameTime gameTime) { // there is no such thing as a selected item on Windows Phone, so we always // force isSelected to be false #if WINDOWS_PHONE isSelected = false; #endif + // When the menu selection changes, entries gradually fade between // their selected and deselected appearance, rather than instantly // popping to the new state. - if (_type != EntryType.Separator) - { - float fadeSpeed = (float)gameTime.ElapsedGameTime.TotalSeconds * 4; - if (isSelected) - { - _selectionFade = Math.Min(_selectionFade + fadeSpeed, 1f); - } - else - { - _selectionFade = Math.Max(_selectionFade - fadeSpeed, 0f); - } - _scale = 0.7f + 0.1f * _selectionFade; - } + float fadeSpeed = (float)gameTime.ElapsedGameTime.TotalSeconds * 4; + + if (isSelected) + selectionFade = Math.Min(selectionFade + fadeSpeed, 1); + else + selectionFade = Math.Max(selectionFade - fadeSpeed, 0); } + /// /// Draws the menu entry. This can be overridden to customize the appearance. /// - public void Draw() + public virtual void Draw(MenuScreen screen, bool isSelected, GameTime gameTime) { - SpriteFont font = _menu.ScreenManager.Fonts.MenuSpriteFont; - SpriteBatch batch = _menu.ScreenManager.SpriteBatch; + // there is no such thing as a selected item on Windows Phone, so we always + // force isSelected to be false +#if WINDOWS_PHONE + isSelected = false; +#endif - Color color; - if (_type == EntryType.Separator) - { - color = Color.DarkOrange; - } - else - { - // Draw the selected entry in yellow, otherwise white - color = Color.Lerp(Color.White, new Color(255, 210, 0), _selectionFade); - } - color *= _alpha; + // Draw the selected entry in yellow, otherwise white. + Color color = isSelected ? Color.Yellow : Color.White; + + // Pulsate the size of the selected menu entry. + double time = gameTime.TotalGameTime.TotalSeconds; + + float pulsate = (float)Math.Sin(time * 6) + 1; + + float scale = 1 + pulsate * 0.05f * selectionFade; + + // Modify the alpha to fade text out during transitions. + color *= screen.TransitionAlpha; // Draw text, centered on the middle of each line. - batch.DrawString(font, _text, _position - _baseOrigin * _scale + Vector2.One, - Color.DarkSlateGray * _alpha * _alpha, 0, Vector2.Zero, _scale, SpriteEffects.None, 0); - batch.DrawString(font, _text, _position - _baseOrigin * _scale, color, 0, Vector2.Zero, _scale, - SpriteEffects.None, 0); + ScreenManager screenManager = screen.ScreenManager; + SpriteBatch spriteBatch = screenManager.SpriteBatch; + SpriteFont font = screenManager.Font; + + Vector2 origin = new Vector2(0, font.LineSpacing / 2); + + spriteBatch.DrawString(font, text, position, color, 0, + origin, scale, SpriteEffects.None, 0); } + /// /// Queries how much space this menu entry requires. /// - public int GetHeight() + public virtual int GetHeight(MenuScreen screen) { - return (int)_height; + return screen.ScreenManager.Font.LineSpacing; } + /// /// Queries how wide the entry is, used for centering on the screen. /// - public int GetWidth() + public virtual int GetWidth(MenuScreen screen) { - return (int)_width; + return (int)screen.ScreenManager.Font.MeasureString(Text).X; } + + + #endregion } -} \ No newline at end of file +} diff --git a/axios/ScreenSystem/MenuScreen.cs b/axios/ScreenSystem/MenuScreen.cs index 2b649d6..b7fe332 100644 --- a/axios/ScreenSystem/MenuScreen.cs +++ b/axios/ScreenSystem/MenuScreen.cs @@ -1,235 +1,169 @@ +#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 FarseerPhysics.SamplesFramework +namespace GameStateManagement { /// /// 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. /// - public class MenuScreen : GameScreen + abstract class MenuScreen : GameScreen { -#if WINDOWS || XBOX - protected const float NumEntries = 15; -#elif WINDOWS_PHONE - protected const float NumEntries = 9; -#endif - protected List _menuEntries = new List(); - protected string _menuTitle; - protected Vector2 _titlePosition; - protected Vector2 _titleOrigin; - protected int _selectedEntry; - protected float _menuBorderTop; - protected float _menuBorderBottom; - protected float _menuBorderMargin; - protected float _menuOffset; - protected float _maxOffset; + #region Fields - protected Texture2D _texScrollButton; - protected Texture2D _texSlider; + List menuEntries = new List(); + int selectedEntry = 0; + string menuTitle; + + InputAction menuUp; + InputAction menuDown; + InputAction menuSelect; + InputAction menuCancel; + + #endregion + + #region Properties + + + /// + /// Gets the list of menu entries, so derived classes can add + /// or change the menu contents. + /// + protected IList MenuEntries + { + get { return menuEntries; } + } + + + #endregion + + #region Initialization - protected MenuButton _scrollUp; - protected MenuButton _scrollDown; - protected MenuButton _scrollSlider; - protected bool _scrollLock; /// /// Constructor. /// public MenuScreen(string menuTitle) { - _menuTitle = menuTitle; + this.menuTitle = menuTitle; - TransitionOnTime = TimeSpan.FromSeconds(0.7); - TransitionOffTime = TimeSpan.FromSeconds(0.7); - HasCursor = true; + 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); } - public void AddMenuItem(string name, EntryType type, GameScreen screen) - { - MenuEntry entry = new MenuEntry(this, name, type, screen); - _menuEntries.Add(entry); - } - public void AddMenuItem(MenuEntry me) - { - _menuEntries.Add(me); - } + #endregion - public override void LoadContent() - { - base.LoadContent(); - - _texScrollButton = ScreenManager.Content.Load("Common/arrow"); - _texSlider = ScreenManager.Content.Load("Common/slider"); + #region Handle Input - //Viewport viewport = ScreenManager.GraphicsDevice.Viewport; - //float scrollBarPos = viewport.Width / 2f; - //scrollBarPos -= _texScrollButton.Width + 2f; - - - - InitMenu(); - - - - } - - public void InitMenu() - { - Viewport viewport = ScreenManager.GraphicsDevice.Viewport; - SpriteFont font = ScreenManager.Fonts.MenuSpriteFont; - float scrollBarPos = viewport.Width / 2f; - - for (int i = 0; i < _menuEntries.Count; ++i) - { - _menuEntries[i].Initialize(); - scrollBarPos = Math.Min(scrollBarPos, - (viewport.Width - _menuEntries[i].GetWidth()) / 2f); - } - - _titleOrigin = font.MeasureString(_menuTitle) / 2f; - _titlePosition = new Vector2(viewport.Width / 2f, font.MeasureString("M").Y / 2f + 10f); - - _menuBorderMargin = font.MeasureString("M").Y * 0.8f; - _menuBorderTop = (viewport.Height - _menuBorderMargin * (NumEntries - 1)) / 2f; - _menuBorderBottom = (viewport.Height + _menuBorderMargin * (NumEntries - 1)) / 2f; - - _menuOffset = 0f; - _maxOffset = Math.Max(0f, (_menuEntries.Count - NumEntries) * _menuBorderMargin); - - _scrollUp = new MenuButton(_texScrollButton, false, - new Vector2(scrollBarPos, _menuBorderTop - _texScrollButton.Height), this); - _scrollDown = new MenuButton(_texScrollButton, true, - new Vector2(scrollBarPos, _menuBorderBottom + _texScrollButton.Height), this); - _scrollSlider = new MenuButton(_texSlider, false, new Vector2(scrollBarPos, _menuBorderTop), this); - - _scrollLock = false; - } - - /// - /// Returns the index of the menu entry at the position of the given mouse state. - /// - /// Index of menu entry if valid, -1 otherwise - private int GetMenuEntryAt(Vector2 position) - { - if (this.TransitionPosition == 0f && this.ScreenState == SamplesFramework.ScreenState.Active) - { - int index = 0; - foreach (MenuEntry entry in _menuEntries) - { - float width = entry.GetWidth(); - float height = entry.GetHeight(); - Rectangle rect = new Rectangle((int)(entry.Position.X - width / 2f), - (int)(entry.Position.Y - height / 2f), - (int)width, (int)height); - if (rect.Contains((int)position.X, (int)position.Y) && entry.Alpha > 0.1f) - { - return index; - } - ++index; - } - } - return -1; - } /// /// Responds to user input, changing the selected entry and accepting /// or cancelling the menu. /// - public override void HandleInput(InputHelper input, GameTime gameTime) + public override void HandleInput(GameTime gameTime, InputState input) { - // Mouse or touch on a menu item - int hoverIndex = GetMenuEntryAt(input.Cursor); - if (hoverIndex > -1 && _menuEntries[hoverIndex].IsSelectable() && !_scrollLock) + // 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. + PlayerIndex playerIndex; + + // Move to the previous menu entry? + if (menuUp.Evaluate(input, ControllingPlayer, out playerIndex)) { - _selectedEntry = hoverIndex; - } - else - { - _selectedEntry = -1; + selectedEntry--; + + if (selectedEntry < 0) + selectedEntry = menuEntries.Count - 1; } - _scrollSlider.Hover = false; - if (input.IsCursorValid) + // Move to the next menu entry? + if (menuDown.Evaluate(input, ControllingPlayer, out playerIndex)) { - _scrollUp.Collide(input.Cursor); - _scrollDown.Collide(input.Cursor); - _scrollSlider.Collide(input.Cursor); - } - else - { - _scrollUp.Hover = false; - _scrollDown.Hover = false; - _scrollLock = false; + selectedEntry++; + + if (selectedEntry >= menuEntries.Count) + selectedEntry = 0; } - // Accept or cancel the menu? - if (input.IsMenuSelect() && _selectedEntry != -1) + if (menuSelect.Evaluate(input, ControllingPlayer, out playerIndex)) { - if (_menuEntries[_selectedEntry].IsExitItem()) - { - ScreenManager.Game.Exit(); - } - else if (_menuEntries[_selectedEntry].IsBackItem()) - { - this.ExitScreen(); - } - else if (_menuEntries[_selectedEntry].Screen != null) - { - ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen); - if (_menuEntries[_selectedEntry].Screen is IDemoScreen) - { - ScreenManager.AddScreen( - new MessageBoxScreen((_menuEntries[_selectedEntry].Screen as IDemoScreen).GetDetails())); - } - } + OnSelectEntry(selectedEntry, playerIndex); } - else if (input.IsMenuCancel()) + else if (menuCancel.Evaluate(input, ControllingPlayer, out playerIndex)) { - if (this.ScreenState == SamplesFramework.ScreenState.Active && this.TransitionPosition == 0 && this.TransitionAlpha == 1) - { - //GameScreen[] screens = ScreenManager.GetScreens(); - //if (screens[screens.Length - 1] is BackgroundScreen ||| screens.Length ) - // ScreenManager.Game.Exit(); - //if (ScreenManager.GetScreens().Length == 2) - // ScreenManager.Game.Exit(); - //else - this.ExitScreen(); - } - //ScreenManager.Game.Exit(); - } - - if (input.IsMenuPressed()) - { - if (_scrollUp.Hover) - { - _menuOffset = Math.Max(_menuOffset - 200f * (float)gameTime.ElapsedGameTime.TotalSeconds, 0f); - _scrollLock = false; - } - if (_scrollDown.Hover) - { - _menuOffset = Math.Min(_menuOffset + 200f * (float)gameTime.ElapsedGameTime.TotalSeconds, _maxOffset); - _scrollLock = false; - } - if (_scrollSlider.Hover) - { - _scrollLock = true; - } - } - if (input.IsMenuReleased()) - { - _scrollLock = false; - } - if (_scrollLock) - { - _scrollSlider.Hover = true; - _menuOffset = Math.Max(Math.Min(((input.Cursor.Y - _menuBorderTop) / (_menuBorderBottom - _menuBorderTop)) * _maxOffset, _maxOffset), 0f); + OnCancel(playerIndex); } } + + /// + /// Handler for when the user has chosen a menu entry. + /// + protected virtual void OnSelectEntry(int entryIndex, PlayerIndex playerIndex) + { + menuEntries[entryIndex].OnSelectEntry(playerIndex); + } + + + /// + /// Handler for when the user has cancelled the menu. + /// + protected virtual void OnCancel(PlayerIndex playerIndex) + { + ExitScreen(); + } + + + /// + /// Helper overload makes it easy to use OnCancel as a MenuEntry event handler. + /// + protected void OnCancel(object sender, PlayerIndexEventArgs e) + { + OnCancel(e.PlayerIndex); + } + + + #endregion + + #region Update and Draw + + /// /// 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. @@ -241,69 +175,49 @@ namespace FarseerPhysics.SamplesFramework // the movement slow down as it nears the end). float transitionOffset = (float)Math.Pow(TransitionPosition, 2); - Vector2 position = Vector2.Zero; - position.Y = _menuBorderTop - _menuOffset; + // 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) + for (int i = 0; i < menuEntries.Count; i++) { - position.X = ScreenManager.GraphicsDevice.Viewport.Width / 2f; + 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 * 256; - } + position.X += transitionOffset * 512; // set the entry's position - _menuEntries[i].Position = position; - - if (position.Y < _menuBorderTop) - { - _menuEntries[i].Alpha = 1f - - Math.Min(_menuBorderTop - position.Y, _menuBorderMargin) / _menuBorderMargin; - } - else if (position.Y > _menuBorderBottom) - { - _menuEntries[i].Alpha = 1f - - Math.Min(position.Y - _menuBorderBottom, _menuBorderMargin) / - _menuBorderMargin; - } - else - { - _menuEntries[i].Alpha = 1f; - } + menuEntry.Position = position; // move down for the next entry the size of this entry - position.Y += _menuEntries[i].GetHeight(); + position.Y += menuEntry.GetHeight(this); } - Vector2 scrollPos = _scrollSlider.Position; - scrollPos.Y = MathHelper.Lerp(_menuBorderTop, _menuBorderBottom, _menuOffset / _maxOffset); - _scrollSlider.Position = scrollPos; } + /// /// Updates the menu. /// public override void Update(GameTime gameTime, bool otherScreenHasFocus, - bool coveredByOtherScreen) + bool coveredByOtherScreen) { base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen); // Update each nested MenuEntry object. - for (int i = 0; i < _menuEntries.Count; ++i) + for (int i = 0; i < menuEntries.Count; i++) { - bool isSelected = IsActive && (i == _selectedEntry); - _menuEntries[i].Update(isSelected, gameTime); - } + bool isSelected = IsActive && (i == selectedEntry); - _scrollUp.Update(gameTime); - _scrollDown.Update(gameTime); - _scrollSlider.Update(gameTime); + menuEntries[i].Update(this, isSelected, gameTime); + } } + /// /// Draws the menu. /// @@ -312,30 +226,42 @@ namespace FarseerPhysics.SamplesFramework // 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.Fonts.MenuSpriteFont; + SpriteFont font = ScreenManager.Font; spriteBatch.Begin(); + // Draw each menu entry in turn. - for (int i = 0; i < _menuEntries.Count; ++i) + for (int i = 0; i < menuEntries.Count; i++) { - bool isSelected = IsActive && (i == _selectedEntry); - _menuEntries[i].Draw(); + 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). - Vector2 transitionOffset = new Vector2(0f, (float)Math.Pow(TransitionPosition, 2) * 100f); + 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.DrawString(font, _menuTitle, _titlePosition - transitionOffset + Vector2.One * 2f, Color.Black, 0, - _titleOrigin, 1f, SpriteEffects.None, 0); - spriteBatch.DrawString(font, _menuTitle, _titlePosition - transitionOffset, new Color(255, 210, 0), 0, - _titleOrigin, 1f, SpriteEffects.None, 0); - _scrollUp.Draw(); - _scrollSlider.Draw(); - _scrollDown.Draw(); spriteBatch.End(); } + + + #endregion } -} \ No newline at end of file +} diff --git a/axios/ScreenSystem/MessageBoxScreen.cs b/axios/ScreenSystem/MessageBoxScreen.cs index d3c9826..55b7a93 100644 --- a/axios/ScreenSystem/MessageBoxScreen.cs +++ b/axios/ScreenSystem/MessageBoxScreen.cs @@ -1,36 +1,87 @@ -using System; +#region File Description +//----------------------------------------------------------------------------- +// MessageBoxScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +#region Using Statements +using System; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Content; using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using GameStateManagement; +#endregion -namespace FarseerPhysics.SamplesFramework +namespace GameStateManagement { /// /// A popup message box screen, used to display "are you sure?" /// confirmation messages. /// - public class MessageBoxScreen : GameScreen + class MessageBoxScreen : GameScreen { - protected Rectangle _backgroundRectangle; - protected Texture2D _gradientTexture; - protected string _message; - protected Vector2 _textPosition; + #region Fields + string message; + Texture2D gradientTexture; + + InputAction menuSelect; + InputAction menuCancel; + + #endregion + + #region Events + + public event EventHandler Accepted; + public event EventHandler Cancelled; + + #endregion + + #region Initialization + + + /// + /// Constructor automatically includes the standard "A=ok, B=cancel" + /// usage text prompt. + /// public MessageBoxScreen(string message) + : this(message, true) + { } + + + /// + /// Constructor lets the caller specify whether to include the standard + /// "A=ok, B=cancel" usage text prompt. + /// + public MessageBoxScreen(string message, bool includeUsageText) { - _message = message; + const string usageText = "\nA button, Space, Enter = ok" + + "\nB button, Esc = cancel"; + + if (includeUsageText) + this.message = message + usageText; + else + this.message = message; IsPopup = true; - HasCursor = true; - TransitionOnTime = TimeSpan.FromSeconds(0.4); - TransitionOffTime = TimeSpan.FromSeconds(0.4); + TransitionOnTime = TimeSpan.FromSeconds(0.2); + TransitionOffTime = TimeSpan.FromSeconds(0.2); + + menuSelect = new InputAction( + new Buttons[] { Buttons.A, Buttons.Start }, + new Keys[] { Keys.Space, Keys.Enter }, + true); + menuCancel = new InputAction( + new Buttons[] { Buttons.B, Buttons.Back }, + new Keys[] { Keys.Escape, Keys.Back }, + true); } - public MessageBoxScreen() - { - IsPopup = true; - } /// /// Loads graphics content for this screen. This uses the shared ContentManager @@ -38,62 +89,98 @@ namespace FarseerPhysics.SamplesFramework /// Whenever a subsequent MessageBoxScreen tries to load this same content, /// it will just get back another reference to the already loaded data. /// - public override void LoadContent() + public override void Activate(bool instancePreserved) { - SpriteFont font = ScreenManager.Fonts.DetailsFont; - ContentManager content = ScreenManager.Game.Content; - _gradientTexture = content.Load("Common/popup"); - - // Center the message text in the viewport. - Viewport viewport = ScreenManager.GraphicsDevice.Viewport; - Vector2 viewportSize = new Vector2(viewport.Width, viewport.Height); - Vector2 textSize = font.MeasureString(_message); - _textPosition = (viewportSize - textSize) / 2; - - // The background includes a border somewhat larger than the text itself. - const int hPad = 32; - const int vPad = 16; - - _backgroundRectangle = new Rectangle((int)_textPosition.X - hPad, - (int)_textPosition.Y - vPad, - (int)textSize.X + hPad * 2, - (int)textSize.Y + vPad * 2); + if (!instancePreserved) + { + ContentManager content = ScreenManager.Game.Content; + gradientTexture = content.Load("gradient"); + } } + + #endregion + + #region Handle Input + + /// /// Responds to user input, accepting or cancelling the message box. /// - public override void HandleInput(InputHelper input, GameTime gameTime) + public override void HandleInput(GameTime gameTime, InputState input) { + PlayerIndex playerIndex; - if (input.IsMenuSelect() || input.IsMenuCancel() || - input.IsNewMouseButtonPress(MouseButtons.LeftButton)) + // 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 our Accepted and + // Cancelled events, so they can tell which player triggered them. + if (menuSelect.Evaluate(input, ControllingPlayer, out playerIndex)) { + // Raise the accepted event, then exit the message box. + if (Accepted != null) + Accepted(this, new PlayerIndexEventArgs(playerIndex)); + + ExitScreen(); + } + else if (menuCancel.Evaluate(input, ControllingPlayer, out playerIndex)) + { + // Raise the cancelled event, then exit the message box. + if (Cancelled != null) + Cancelled(this, new PlayerIndexEventArgs(playerIndex)); + ExitScreen(); } } + + #endregion + + #region Draw + + /// /// Draws the message box. /// public override void Draw(GameTime gameTime) { SpriteBatch spriteBatch = ScreenManager.SpriteBatch; - SpriteFont font = ScreenManager.Fonts.DetailsFont; + SpriteFont font = ScreenManager.Font; + + // Darken down any other screens that were drawn beneath the popup. + ScreenManager.FadeBackBufferToBlack(TransitionAlpha * 2 / 3); + + // Center the message 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; + + // The background includes a border somewhat larger than the text itself. + const int hPad = 32; + const int vPad = 16; + + Rectangle backgroundRectangle = new Rectangle((int)textPosition.X - hPad, + (int)textPosition.Y - vPad, + (int)textSize.X + hPad * 2, + (int)textSize.Y + vPad * 2); // Fade the popup alpha during transitions. - Color color = Color.White * TransitionAlpha * (2f / 3f); + Color color = Color.White * TransitionAlpha; spriteBatch.Begin(); // Draw the background rectangle. - spriteBatch.Draw(_gradientTexture, _backgroundRectangle, color); + spriteBatch.Draw(gradientTexture, backgroundRectangle, color); // Draw the message box text. - spriteBatch.DrawString(font, _message, _textPosition + Vector2.One, Color.Black); - spriteBatch.DrawString(font, _message, _textPosition, Color.White); + spriteBatch.DrawString(font, message, textPosition, color); spriteBatch.End(); } + + + #endregion } -} \ No newline at end of file +} diff --git a/axios/ScreenSystem/PhysicsGameScreen.cs b/axios/ScreenSystem/PhysicsGameScreen.cs index 30fc9f0..fafc036 100644 --- a/axios/ScreenSystem/PhysicsGameScreen.cs +++ b/axios/ScreenSystem/PhysicsGameScreen.cs @@ -6,9 +6,10 @@ using FarseerPhysics.Dynamics.Joints; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Content; using Microsoft.Xna.Framework.Input; +using FarseerPhysics.SamplesFramework; using Axios.Engine; -namespace FarseerPhysics.SamplesFramework +namespace GameStateManagement { public class PhysicsGameScreen : GameScreen { @@ -47,48 +48,51 @@ namespace FarseerPhysics.SamplesFramework _agentTorque = torque; } - - public override void LoadContent() + + public override void Activate(bool instancePreserved) { - base.LoadContent(); - - //We enable diagnostics to show get values for our performance counters. - Settings.EnableDiagnostics = true; - - if (World == null) + if (!instancePreserved) { - World = new World(Vector2.Zero); - } - else - { - World.Clear(); - } + base.Activate(instancePreserved); - if (DebugView == null) - { - if (!Axios.Settings.ScreenSaver) + //We enable diagnostics to show get values for our performance counters. + Settings.EnableDiagnostics = true; + + if (World == null) { - DebugView = new DebugViewXNA(World); - DebugView.RemoveFlags(DebugViewFlags.Shape); - DebugView.RemoveFlags(DebugViewFlags.Joint); - DebugView.DefaultShapeColor = Color.White; - DebugView.SleepingShapeColor = Color.LightGray; - DebugView.LoadContent(ScreenManager.GraphicsDevice, ScreenManager.Content); + World = new World(Vector2.Zero); + } + else + { + World.Clear(); } - } - if (Camera == null) - { - Camera = new Camera2D(ScreenManager.GraphicsDevice); - } - else - { - Camera.ResetCamera(); - } + if (DebugView == null) + { + if (!Axios.Settings.ScreenSaver) + { + DebugView = new DebugViewXNA(World); + DebugView.RemoveFlags(DebugViewFlags.Shape); + DebugView.RemoveFlags(DebugViewFlags.Joint); + DebugView.DefaultShapeColor = Color.White; + DebugView.SleepingShapeColor = Color.LightGray; + DebugView.LoadContent(ScreenManager.GraphicsDevice, ScreenManager.Content); + } + } - // Loading may take a while... so prevent the game from "catching up" once we finished loading - ScreenManager.Game.ResetElapsedTime(); + if (Camera == null) + { + Camera = new Camera2D(ScreenManager.GraphicsDevice); + } + else + { + Camera.ResetCamera(); + } + + // Loading may take a while... so prevent the game from "catching up" once we finished loading + ScreenManager.Game.ResetElapsedTime(); + } } public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen) @@ -110,12 +114,13 @@ namespace FarseerPhysics.SamplesFramework { } - public override void HandleInput(InputHelper input, GameTime gameTime) + public override void HandleInput(GameTime gameTime, InputState input) { #if DEBUG // Control debug view - if (input.IsNewButtonPress(Buttons.Start)) + PlayerIndex player; + if (input.IsNewButtonPress(Buttons.Start, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.Shape); EnableOrDisableFlag(DebugViewFlags.DebugPanel); @@ -126,37 +131,37 @@ namespace FarseerPhysics.SamplesFramework EnableOrDisableFlag(DebugViewFlags.Controllers); } - if (input.IsNewKeyPress(Keys.F1)) + if (input.IsNewKeyPress(Keys.F1, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.Shape); } - if (input.IsNewKeyPress(Keys.F2)) + if (input.IsNewKeyPress(Keys.F2, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.DebugPanel); EnableOrDisableFlag(DebugViewFlags.PerformanceGraph); } - if (input.IsNewKeyPress(Keys.F3)) + if (input.IsNewKeyPress(Keys.F3, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.Joint); } - if (input.IsNewKeyPress(Keys.F4)) + if (input.IsNewKeyPress(Keys.F4, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.ContactPoints); EnableOrDisableFlag(DebugViewFlags.ContactNormals); } - if (input.IsNewKeyPress(Keys.F5)) + if (input.IsNewKeyPress(Keys.F5, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.PolygonPoints); } - if (input.IsNewKeyPress(Keys.F6)) + if (input.IsNewKeyPress(Keys.F6, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.Controllers); } - if (input.IsNewKeyPress(Keys.F7)) + if (input.IsNewKeyPress(Keys.F7, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.CenterOfMass); } - if (input.IsNewKeyPress(Keys.F8)) + if (input.IsNewKeyPress(Keys.F8, ControllingPlayer.Value, out player)) { EnableOrDisableFlag(DebugViewFlags.AABB); } @@ -181,7 +186,7 @@ namespace FarseerPhysics.SamplesFramework if (input.IsNewButtonPress(Buttons.Back) || input.IsNewKeyPress(Keys.Escape)) { - if (this.ScreenState == SamplesFramework.ScreenState.Active && this.TransitionPosition == 0 && this.TransitionAlpha == 1) + if (this.ScreenState == GameStateManagement.ScreenState.Active && this.TransitionPosition == 0 && this.TransitionAlpha == 1) { //Give the screens a chance to transition CleanUp(); @@ -191,9 +196,10 @@ namespace FarseerPhysics.SamplesFramework } base.HandleInput(input, gameTime); } - - public virtual void HandleCursor(InputHelper input) + + public virtual void HandleCursor(InputState input) { + PlayerIndex player; Vector2 position = Camera.ConvertScreenToWorld(input.Cursor); if ((input.IsNewButtonPress(Buttons.A) || @@ -211,8 +217,9 @@ namespace FarseerPhysics.SamplesFramework } } - if ((input.IsNewButtonRelease(Buttons.A) || - input.IsNewMouseButtonRelease(MouseButtons.LeftButton)) && + + if ((input.IsNewButtonRelease(Buttons.A, ControllingPlayer.Value, out player) || + input.IsNewMouseButtonRelease(MouseButtons.LeftButton, ControllingPlayer.Value, out player)) && _fixedMouseJoint != null) { World.RemoveJoint(_fixedMouseJoint); diff --git a/axios/ScreenSystem/ScreenManagerComponent.cs b/axios/ScreenSystem/ScreenManagerComponent.cs index 2705ce0..7303f72 100644 --- a/axios/ScreenSystem/ScreenManagerComponent.cs +++ b/axios/ScreenSystem/ScreenManagerComponent.cs @@ -3,9 +3,11 @@ using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Content; using Microsoft.Xna.Framework.Graphics; using Microsoft.Xna.Framework.Input.Touch; +using FarseerPhysics.SamplesFramework; -namespace FarseerPhysics.SamplesFramework +namespace GameStateManagement { + /* /// /// The screen manager is a component which manages one or more GameScreen /// instances. It maintains a stack of screens, calls their Update and Draw @@ -299,5 +301,5 @@ namespace FarseerPhysics.SamplesFramework { return _screens.ToArray(); } - } + }*/ } \ No newline at end of file From a93df07c6ed6fe642607e9b1f6c1113a4ffc5917 Mon Sep 17 00:00:00 2001 From: "nathan@daedalus" Date: Thu, 12 Apr 2012 22:20:50 -0500 Subject: [PATCH 2/7] Adding supporting files --HG-- branch : axios-newgsm --- axios/ScreenSystem/Button.cs | 191 +++++++++ axios/ScreenSystem/GameplayScreen.cs | 265 ++++++++++++ axios/ScreenSystem/IScreenFactory.cs | 49 +++ axios/ScreenSystem/InputAction.cs | 96 +++++ axios/ScreenSystem/InputState.cs | 233 +++++++++++ axios/ScreenSystem/LoadingScreen.cs | 163 ++++++++ axios/ScreenSystem/MainMenuScreen.cs | 98 +++++ axios/ScreenSystem/OptionsMenuScreen.cs | 149 +++++++ axios/ScreenSystem/PauseMenuScreen.cs | 79 ++++ axios/ScreenSystem/PhoneMainMenuScreen.cs | 65 +++ axios/ScreenSystem/PhoneMenuScreen.cs | 149 +++++++ axios/ScreenSystem/PhonePauseScreen.cs | 57 +++ axios/ScreenSystem/PlayerIndexEventArgs.cs | 42 ++ axios/ScreenSystem/ScreenManager.cs | 447 +++++++++++++++++++++ 14 files changed, 2083 insertions(+) create mode 100644 axios/ScreenSystem/Button.cs create mode 100644 axios/ScreenSystem/GameplayScreen.cs create mode 100644 axios/ScreenSystem/IScreenFactory.cs create mode 100644 axios/ScreenSystem/InputAction.cs create mode 100644 axios/ScreenSystem/InputState.cs create mode 100644 axios/ScreenSystem/LoadingScreen.cs create mode 100644 axios/ScreenSystem/MainMenuScreen.cs create mode 100644 axios/ScreenSystem/OptionsMenuScreen.cs create mode 100644 axios/ScreenSystem/PauseMenuScreen.cs create mode 100644 axios/ScreenSystem/PhoneMainMenuScreen.cs create mode 100644 axios/ScreenSystem/PhoneMenuScreen.cs create mode 100644 axios/ScreenSystem/PhonePauseScreen.cs create mode 100644 axios/ScreenSystem/PlayerIndexEventArgs.cs create mode 100644 axios/ScreenSystem/ScreenManager.cs diff --git a/axios/ScreenSystem/Button.cs b/axios/ScreenSystem/Button.cs new file mode 100644 index 0000000..1cd60d7 --- /dev/null +++ b/axios/ScreenSystem/Button.cs @@ -0,0 +1,191 @@ +#region File Description +//----------------------------------------------------------------------------- +// Button.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +using System; +using GameStateManagement; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace GameStateManagement +{ + /// + /// A special button that handles toggling between "On" and "Off" + /// + class BooleanButton : Button + { + private string option; + private bool value; + + /// + /// Creates a new BooleanButton. + /// + /// The string text to display for the option. + /// The initial value of the button. + public BooleanButton(string option, bool value) + : base(option) + { + this.option = option; + this.value = value; + + GenerateText(); + } + + protected override void OnTapped() + { + // When tapped we need to toggle the value and regenerate the text + value = !value; + GenerateText(); + + base.OnTapped(); + } + + /// + /// Helper that generates the actual Text value the base class uses for drawing. + /// + private void GenerateText() + { + Text = string.Format("{0}: {1}", option, value ? "On" : "Off"); + } + } + + /// + /// Represents a touchable button. + /// + class Button + { + /// + /// The text displayed in the button. + /// + public string Text = "Button"; + + /// + /// The position of the top-left corner of the button. + /// + public Vector2 Position = Vector2.Zero; + + /// + /// The size of the button. + /// + public Vector2 Size = new Vector2(250, 75); + + /// + /// The thickness of the border drawn for the button. + /// + public int BorderThickness = 4; + + /// + /// The color of the button border. + /// + public Color BorderColor = new Color(200, 200, 200); + + /// + /// The color of the button background. + /// + public Color FillColor = new Color(100, 100, 100) * .75f; + + /// + /// The color of the text. + /// + public Color TextColor = Color.White; + + /// + /// The opacity of the button. + /// + public float Alpha = 0f; + + /// + /// Invoked when the button is tapped. + /// + public event EventHandler Tapped; + + /// + /// Creates a new Button. + /// + /// The text to display in the button. + public Button(string text) + { + Text = text; + } + + /// + /// Invokes the Tapped event and allows subclasses to perform actions when tapped. + /// + protected virtual void OnTapped() + { + if (Tapped != null) + Tapped(this, EventArgs.Empty); + } + + /// + /// Passes a tap location to the button for handling. + /// + /// The location of the tap. + /// True if the button was tapped, false otherwise. + public bool HandleTap(Vector2 tap) + { + if (tap.X >= Position.X && + tap.Y >= Position.Y && + tap.X <= Position.X + Size.X && + tap.Y <= Position.Y + Size.Y) + { + OnTapped(); + return true; + } + + return false; + } + + /// + /// Draws the button + /// + /// The screen drawing the button + public void Draw(GameScreen screen) + { + // Grab some common items from the ScreenManager + SpriteBatch spriteBatch = screen.ScreenManager.SpriteBatch; + SpriteFont font = screen.ScreenManager.Font; + Texture2D blank = screen.ScreenManager.BlankTexture; + + // Compute the button's rectangle + Rectangle r = new Rectangle( + (int)Position.X, + (int)Position.Y, + (int)Size.X, + (int)Size.Y); + + // Fill the button + spriteBatch.Draw(blank, r, FillColor * Alpha); + + // Draw the border + spriteBatch.Draw( + blank, + new Rectangle(r.Left, r.Top, r.Width, BorderThickness), + BorderColor * Alpha); + spriteBatch.Draw( + blank, + new Rectangle(r.Left, r.Top, BorderThickness, r.Height), + BorderColor * Alpha); + spriteBatch.Draw( + blank, + new Rectangle(r.Right - BorderThickness, r.Top, BorderThickness, r.Height), + BorderColor * Alpha); + spriteBatch.Draw( + blank, + new Rectangle(r.Left, r.Bottom - BorderThickness, r.Width, BorderThickness), + BorderColor * Alpha); + + // Draw the text centered in the button + Vector2 textSize = font.MeasureString(Text); + Vector2 textPosition = new Vector2(r.Center.X, r.Center.Y) - textSize / 2f; + textPosition.X = (int)textPosition.X; + textPosition.Y = (int)textPosition.Y; + spriteBatch.DrawString(font, Text, textPosition, TextColor * Alpha); + } + } +} diff --git a/axios/ScreenSystem/GameplayScreen.cs b/axios/ScreenSystem/GameplayScreen.cs new file mode 100644 index 0000000..a2be8be --- /dev/null +++ b/axios/ScreenSystem/GameplayScreen.cs @@ -0,0 +1,265 @@ +#region File Description +//----------------------------------------------------------------------------- +// GameplayScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +#region Using Statements +using System; +using System.Threading; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using GameStateManagement; +#endregion + +namespace GameStateManagementSample +{ + /// + /// This screen implements the actual game logic. It is just a + /// placeholder to get the idea across: you'll probably want to + /// put some more interesting gameplay in here! + /// + class GameplayScreen : GameScreen + { + #region Fields + + ContentManager content; + SpriteFont gameFont; + + Vector2 playerPosition = new Vector2(100, 100); + Vector2 enemyPosition = new Vector2(100, 100); + + Random random = new Random(); + + float pauseAlpha; + + InputAction pauseAction; + + #endregion + + #region Initialization + + + /// + /// Constructor. + /// + public GameplayScreen() + { + TransitionOnTime = TimeSpan.FromSeconds(1.5); + TransitionOffTime = TimeSpan.FromSeconds(0.5); + + pauseAction = new InputAction( + new Buttons[] { Buttons.Start, Buttons.Back }, + new Keys[] { Keys.Escape }, + true); + } + + + /// + /// Load graphics content for the game. + /// + public override void Activate(bool instancePreserved) + { + if (!instancePreserved) + { + if (content == null) + content = new ContentManager(ScreenManager.Game.Services, "Content"); + + gameFont = content.Load("gamefont"); + + // A real game would probably have more content than this sample, so + // it would take longer to load. We simulate that by delaying for a + // while, giving you a chance to admire the beautiful loading screen. + Thread.Sleep(1000); + + // once the load has finished, we use ResetElapsedTime to tell the game's + // timing mechanism that we have just finished a very long frame, and that + // it should not try to catch up. + ScreenManager.Game.ResetElapsedTime(); + } + +#if WINDOWS_PHONE + if (Microsoft.Phone.Shell.PhoneApplicationService.Current.State.ContainsKey("PlayerPosition")) + { + playerPosition = (Vector2)Microsoft.Phone.Shell.PhoneApplicationService.Current.State["PlayerPosition"]; + enemyPosition = (Vector2)Microsoft.Phone.Shell.PhoneApplicationService.Current.State["EnemyPosition"]; + } +#endif + } + + + public override void Deactivate() + { +#if WINDOWS_PHONE + Microsoft.Phone.Shell.PhoneApplicationService.Current.State["PlayerPosition"] = playerPosition; + Microsoft.Phone.Shell.PhoneApplicationService.Current.State["EnemyPosition"] = enemyPosition; +#endif + + base.Deactivate(); + } + + + /// + /// Unload graphics content used by the game. + /// + public override void Unload() + { + content.Unload(); + +#if WINDOWS_PHONE + Microsoft.Phone.Shell.PhoneApplicationService.Current.State.Remove("PlayerPosition"); + Microsoft.Phone.Shell.PhoneApplicationService.Current.State.Remove("EnemyPosition"); +#endif + } + + + #endregion + + #region Update and Draw + + + /// + /// Updates the state of the game. This method checks the GameScreen.IsActive + /// property, so the game will stop updating when the pause menu is active, + /// or if you tab away to a different application. + /// + public override void Update(GameTime gameTime, bool otherScreenHasFocus, + bool coveredByOtherScreen) + { + base.Update(gameTime, otherScreenHasFocus, false); + + // Gradually fade in or out depending on whether we are covered by the pause screen. + if (coveredByOtherScreen) + pauseAlpha = Math.Min(pauseAlpha + 1f / 32, 1); + else + pauseAlpha = Math.Max(pauseAlpha - 1f / 32, 0); + + if (IsActive) + { + // Apply some random jitter to make the enemy move around. + const float randomization = 10; + + enemyPosition.X += (float)(random.NextDouble() - 0.5) * randomization; + enemyPosition.Y += (float)(random.NextDouble() - 0.5) * randomization; + + // Apply a stabilizing force to stop the enemy moving off the screen. + Vector2 targetPosition = new Vector2( + ScreenManager.GraphicsDevice.Viewport.Width / 2 - gameFont.MeasureString("Insert Gameplay Here").X / 2, + 200); + + enemyPosition = Vector2.Lerp(enemyPosition, targetPosition, 0.05f); + + // TODO: this game isn't very fun! You could probably improve + // it by inserting something more interesting in this space :-) + } + } + + + /// + /// Lets the game respond to player input. Unlike the Update method, + /// this will only be called when the gameplay screen is active. + /// + public override void HandleInput(GameTime gameTime, InputState input) + { + if (input == null) + throw new ArgumentNullException("input"); + + // Look up inputs for the active player profile. + int playerIndex = (int)ControllingPlayer.Value; + + KeyboardState keyboardState = input.CurrentKeyboardStates[playerIndex]; + GamePadState gamePadState = input.CurrentGamePadStates[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[playerIndex]; + + PlayerIndex player; + if (pauseAction.Evaluate(input, ControllingPlayer, out player) || gamePadDisconnected) + { +#if WINDOWS_PHONE + ScreenManager.AddScreen(new PhonePauseScreen(), ControllingPlayer); +#else + ScreenManager.AddScreen(new PauseMenuScreen(), ControllingPlayer); +#endif + } + else + { + // Otherwise move the player position. + Vector2 movement = Vector2.Zero; + + if (keyboardState.IsKeyDown(Keys.Left)) + movement.X--; + + if (keyboardState.IsKeyDown(Keys.Right)) + movement.X++; + + if (keyboardState.IsKeyDown(Keys.Up)) + movement.Y--; + + if (keyboardState.IsKeyDown(Keys.Down)) + movement.Y++; + + Vector2 thumbstick = gamePadState.ThumbSticks.Left; + + movement.X += thumbstick.X; + movement.Y -= thumbstick.Y; + + if (input.TouchState.Count > 0) + { + Vector2 touchPosition = input.TouchState[0].Position; + Vector2 direction = touchPosition - playerPosition; + direction.Normalize(); + movement += direction; + } + + if (movement.Length() > 1) + movement.Normalize(); + + playerPosition += movement * 8f; + } + } + + + /// + /// Draws the gameplay screen. + /// + public override void Draw(GameTime gameTime) + { + // This game has a blue background. Why? Because! + ScreenManager.GraphicsDevice.Clear(ClearOptions.Target, + Color.CornflowerBlue, 0, 0); + + // Our player and enemy are both actually just text strings. + SpriteBatch spriteBatch = ScreenManager.SpriteBatch; + + spriteBatch.Begin(); + + spriteBatch.DrawString(gameFont, "// TODO", playerPosition, Color.Green); + + spriteBatch.DrawString(gameFont, "Insert Gameplay Here", + enemyPosition, Color.DarkRed); + + spriteBatch.End(); + + // If the game is transitioning on or off, fade it out to black. + if (TransitionPosition > 0 || pauseAlpha > 0) + { + float alpha = MathHelper.Lerp(1f - TransitionAlpha, 1f, pauseAlpha / 2); + + ScreenManager.FadeBackBufferToBlack(alpha); + } + } + + + #endregion + } +} diff --git a/axios/ScreenSystem/IScreenFactory.cs b/axios/ScreenSystem/IScreenFactory.cs new file mode 100644 index 0000000..10a81fb --- /dev/null +++ b/axios/ScreenSystem/IScreenFactory.cs @@ -0,0 +1,49 @@ +#region File Description +//----------------------------------------------------------------------------- +// IScreenFactory.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +using System; + +namespace GameStateManagement +{ + /// + /// Defines an object that can create a screen when given its type. + /// + /// The ScreenManager attempts to handle tombstoning on Windows Phone by creating an XML + /// document that has a list of the screens currently in the manager. When the game is + /// reactivated, the ScreenManager needs to create instances of those screens. However + /// since there is no restriction that a particular GameScreen subclass has a parameterless + /// constructor, there is no way the ScreenManager alone could create those instances. + /// + /// IScreenFactory fills this gap by providing an interface the game should implement to + /// act as a translation from type to instance. The ScreenManager locates the IScreenFactory + /// from the Game.Services collection and passes each screen type to the factory, expecting + /// to get the correct GameScreen out. + /// + /// If your game screens all have parameterless constructors, the minimal implementation of + /// this interface would look like this: + /// + /// return Activator.CreateInstance(screenType) as GameScreen; + /// + /// If you have screens with constructors that take arguments, you will need to ensure that + /// you can read these arguments from storage or generate new ones, then construct the screen + /// based on the type. + /// + /// The ScreenFactory type in the sample game has the minimal implementation along with some + /// extra comments showing a potentially more complex example of how to implement IScreenFactory. + /// + public interface IScreenFactory + { + /// + /// Creates a GameScreen from the given type. + /// + /// The type of screen to create. + /// The newly created screen. + GameScreen CreateScreen(Type screenType); + } +} diff --git a/axios/ScreenSystem/InputAction.cs b/axios/ScreenSystem/InputAction.cs new file mode 100644 index 0000000..97e9b7a --- /dev/null +++ b/axios/ScreenSystem/InputAction.cs @@ -0,0 +1,96 @@ +#region File Description +//----------------------------------------------------------------------------- +// InputAction.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +using System; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Input; + +namespace GameStateManagement +{ + /// + /// Defines an action that is designated by some set of buttons and/or keys. + /// + /// The way actions work is that you define a set of buttons and keys that trigger the action. You can + /// then evaluate the action against an InputState which will test to see if any of the buttons or keys + /// are pressed by a player. You can also set a flag that indicates if the action only occurs once when + /// the buttons/keys are first pressed or whether the action should occur each frame. + /// + /// Using this InputAction class means that you can configure new actions based on keys and buttons + /// without having to directly modify the InputState type. This means more customization by your games + /// without having to change the core classes of Game State Management. + /// + public class InputAction + { + private readonly Buttons[] buttons; + private readonly Keys[] keys; + private readonly bool newPressOnly; + + // These delegate types map to the methods on InputState. We use these to simplify the evalute method + // by allowing us to map the appropriate delegates and invoke them, rather than having two separate code paths. + private delegate bool ButtonPress(Buttons button, PlayerIndex? controllingPlayer, out PlayerIndex player); + private delegate bool KeyPress(Keys key, PlayerIndex? controllingPlayer, out PlayerIndex player); + + /// + /// Initializes a new InputAction. + /// + /// An array of buttons that can trigger the action. + /// An array of keys that can trigger the action. + /// Whether the action only occurs on the first press of one of the buttons/keys, + /// false if it occurs each frame one of the buttons/keys is down. + public InputAction(Buttons[] buttons, Keys[] keys, bool newPressOnly) + { + // Store the buttons and keys. If the arrays are null, we create a 0 length array so we don't + // have to do null checks in the Evaluate method + this.buttons = buttons != null ? buttons.Clone() as Buttons[] : new Buttons[0]; + this.keys = keys != null ? keys.Clone() as Keys[] : new Keys[0]; + + this.newPressOnly = newPressOnly; + } + + /// + /// Evaluates the action against a given InputState. + /// + /// The InputState to test for the action. + /// The player to test, or null to allow any player. + /// If controllingPlayer is null, this is the player that performed the action. + /// True if the action occurred, false otherwise. + public bool Evaluate(InputState state, PlayerIndex? controllingPlayer, out PlayerIndex player) + { + // Figure out which delegate methods to map from the state which takes care of our "newPressOnly" logic + ButtonPress buttonTest; + KeyPress keyTest; + if (newPressOnly) + { + buttonTest = state.IsNewButtonPress; + keyTest = state.IsNewKeyPress; + } + else + { + buttonTest = state.IsButtonPressed; + keyTest = state.IsKeyPressed; + } + + // Now we simply need to invoke the appropriate methods for each button and key in our collections + foreach (Buttons button in buttons) + { + if (buttonTest(button, controllingPlayer, out player)) + return true; + } + foreach (Keys key in keys) + { + if (keyTest(key, controllingPlayer, out player)) + return true; + } + + // If we got here, the action is not matched + player = PlayerIndex.One; + return false; + } + } +} diff --git a/axios/ScreenSystem/InputState.cs b/axios/ScreenSystem/InputState.cs new file mode 100644 index 0000000..1446751 --- /dev/null +++ b/axios/ScreenSystem/InputState.cs @@ -0,0 +1,233 @@ +#region File Description +//----------------------------------------------------------------------------- +// InputState.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +using System.Collections.Generic; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Input.Touch; +using FarseerPhysics.SamplesFramework; + +namespace GameStateManagement +{ + /// + /// Helper for reading input from keyboard, gamepad, and touch input. This class + /// tracks both the current and previous state of the input devices, and implements + /// query methods for high level input actions such as "move up through the menu" + /// or "pause the game". + /// + public class InputState + { + public const int MaxInputs = 4; + + public readonly KeyboardState[] CurrentKeyboardStates; + public readonly GamePadState[] CurrentGamePadStates; + + public readonly KeyboardState[] LastKeyboardStates; + public readonly GamePadState[] LastGamePadStates; + + public readonly bool[] GamePadWasConnected; + + /* + * Needed for virtual stick on WP7 + * -- Nathan Adams [adamsna@datanethost.net] - 4/12/2012 + */ + private GamePadState _currentVirtualState; + private GamePadState _lastVirtualState; + private bool _handleVirtualStick; + /* + * I didn't create an array for the virtual stick because there will only be one + * -- Nathan Adams [adamsna@datanethost.net] - 4/12/2012 + */ + + + /* + * + * + * + * + * + */ + private Vector2 _cursor; + private bool _cursorIsValid; + private bool _cursorIsVisible; + private bool _cursorMoved; + private Sprite _cursorSprite; + +#if WINDOWS_PHONE + private VirtualStick _phoneStick; + private VirtualButton _phoneA; + private VirtualButton _phoneB; +#endif + + public TouchCollection TouchState; + + public readonly List Gestures = new List(); + + + /// + /// Constructs a new input state. + /// + public InputState() + { + CurrentKeyboardStates = new KeyboardState[MaxInputs]; + CurrentGamePadStates = new GamePadState[MaxInputs]; + + LastKeyboardStates = new KeyboardState[MaxInputs]; + LastGamePadStates = new GamePadState[MaxInputs]; + + GamePadWasConnected = new bool[MaxInputs]; + } + + /// + /// Reads the latest state user input. + /// + public void Update() + { + for (int i = 0; i < MaxInputs; i++) + { + LastKeyboardStates[i] = CurrentKeyboardStates[i]; + LastGamePadStates[i] = CurrentGamePadStates[i]; + + CurrentKeyboardStates[i] = Keyboard.GetState((PlayerIndex)i); + CurrentGamePadStates[i] = GamePad.GetState((PlayerIndex)i); + + // Keep track of whether a gamepad has ever been + // connected, so we can detect if it is unplugged. + if (CurrentGamePadStates[i].IsConnected) + { + GamePadWasConnected[i] = true; + } + } + + // Get the raw touch state from the TouchPanel + TouchState = TouchPanel.GetState(); + + // Read in any detected gestures into our list for the screens to later process + Gestures.Clear(); + while (TouchPanel.IsGestureAvailable) + { + Gestures.Add(TouchPanel.ReadGesture()); + } + } + + + /// + /// Helper for checking if a key was pressed during this update. The + /// controllingPlayer parameter specifies which player to read input for. + /// If this is null, it will accept input from any player. When a keypress + /// is detected, the output playerIndex reports which player pressed it. + /// + public bool IsKeyPressed(Keys key, PlayerIndex? controllingPlayer, out PlayerIndex playerIndex) + { + if (controllingPlayer.HasValue) + { + // Read input from the specified player. + playerIndex = controllingPlayer.Value; + + int i = (int)playerIndex; + + return CurrentKeyboardStates[i].IsKeyDown(key); + } + else + { + // Accept input from any player. + return (IsKeyPressed(key, PlayerIndex.One, out playerIndex) || + IsKeyPressed(key, PlayerIndex.Two, out playerIndex) || + IsKeyPressed(key, PlayerIndex.Three, out playerIndex) || + IsKeyPressed(key, PlayerIndex.Four, out playerIndex)); + } + } + + + /// + /// Helper for checking if a button was pressed during this update. + /// The controllingPlayer parameter specifies which player to read input for. + /// If this is null, it will accept input from any player. When a button press + /// is detected, the output playerIndex reports which player pressed it. + /// + public bool IsButtonPressed(Buttons button, PlayerIndex? controllingPlayer, out PlayerIndex playerIndex) + { + if (controllingPlayer.HasValue) + { + // Read input from the specified player. + playerIndex = controllingPlayer.Value; + + int i = (int)playerIndex; + + return CurrentGamePadStates[i].IsButtonDown(button); + } + else + { + // Accept input from any player. + return (IsButtonPressed(button, PlayerIndex.One, out playerIndex) || + IsButtonPressed(button, PlayerIndex.Two, out playerIndex) || + IsButtonPressed(button, PlayerIndex.Three, out playerIndex) || + IsButtonPressed(button, PlayerIndex.Four, out playerIndex)); + } + } + + + /// + /// Helper for checking if a key was newly pressed during this update. The + /// controllingPlayer parameter specifies which player to read input for. + /// If this is null, it will accept input from any player. When a keypress + /// is detected, the output playerIndex reports which player pressed it. + /// + public bool IsNewKeyPress(Keys key, PlayerIndex? controllingPlayer, out PlayerIndex playerIndex) + { + if (controllingPlayer.HasValue) + { + // Read input from the specified player. + playerIndex = controllingPlayer.Value; + + int i = (int)playerIndex; + + return (CurrentKeyboardStates[i].IsKeyDown(key) && + LastKeyboardStates[i].IsKeyUp(key)); + } + else + { + // Accept input from any player. + return (IsNewKeyPress(key, PlayerIndex.One, out playerIndex) || + IsNewKeyPress(key, PlayerIndex.Two, out playerIndex) || + IsNewKeyPress(key, PlayerIndex.Three, out playerIndex) || + IsNewKeyPress(key, PlayerIndex.Four, out playerIndex)); + } + } + + + /// + /// Helper for checking if a button was newly pressed during this update. + /// The controllingPlayer parameter specifies which player to read input for. + /// If this is null, it will accept input from any player. When a button press + /// is detected, the output playerIndex reports which player pressed it. + /// + public bool IsNewButtonPress(Buttons button, PlayerIndex? controllingPlayer, out PlayerIndex playerIndex) + { + if (controllingPlayer.HasValue) + { + // Read input from the specified player. + playerIndex = controllingPlayer.Value; + + int i = (int)playerIndex; + + return (CurrentGamePadStates[i].IsButtonDown(button) && + LastGamePadStates[i].IsButtonUp(button)); + } + else + { + // Accept input from any player. + return (IsNewButtonPress(button, PlayerIndex.One, out playerIndex) || + IsNewButtonPress(button, PlayerIndex.Two, out playerIndex) || + IsNewButtonPress(button, PlayerIndex.Three, out playerIndex) || + IsNewButtonPress(button, PlayerIndex.Four, out playerIndex)); + } + } + } +} diff --git a/axios/ScreenSystem/LoadingScreen.cs b/axios/ScreenSystem/LoadingScreen.cs new file mode 100644 index 0000000..0d5cf24 --- /dev/null +++ b/axios/ScreenSystem/LoadingScreen.cs @@ -0,0 +1,163 @@ +#region File Description +//----------------------------------------------------------------------------- +// LoadingScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +#region Using Statements +using System; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using GameStateManagement; +#endregion + +namespace GameStateManagement +{ + /// + /// The loading screen coordinates transitions between the menu system and the + /// game itself. Normally one screen will transition off at the same time as + /// the next screen is transitioning on, but for larger transitions that can + /// take a longer time to load their data, we want the menu system to be entirely + /// gone before we start loading the game. This is done as follows: + /// + /// - Tell all the existing screens to transition off. + /// - Activate a loading screen, which will transition on at the same time. + /// - The loading screen watches the state of the previous screens. + /// - When it sees they have finished transitioning off, it activates the real + /// next screen, which may take a long time to load its data. The loading + /// screen will be the only thing displayed while this load is taking place. + /// + class LoadingScreen : GameScreen + { + #region Fields + + bool loadingIsSlow; + bool otherScreensAreGone; + + GameScreen[] screensToLoad; + + #endregion + + #region Initialization + + + /// + /// The constructor is private: loading screens should + /// be activated via the static Load method instead. + /// + private LoadingScreen(ScreenManager screenManager, bool loadingIsSlow, + GameScreen[] screensToLoad) + { + this.loadingIsSlow = loadingIsSlow; + this.screensToLoad = screensToLoad; + + TransitionOnTime = TimeSpan.FromSeconds(0.5); + } + + + /// + /// Activates the loading screen. + /// + public static void Load(ScreenManager screenManager, bool loadingIsSlow, + PlayerIndex? controllingPlayer, + params GameScreen[] screensToLoad) + { + // Tell all the current screens to transition off. + foreach (GameScreen screen in screenManager.GetScreens()) + screen.ExitScreen(); + + // Create and activate the loading screen. + LoadingScreen loadingScreen = new LoadingScreen(screenManager, + loadingIsSlow, + screensToLoad); + + screenManager.AddScreen(loadingScreen, controllingPlayer); + } + + + #endregion + + #region Update and Draw + + + /// + /// Updates the loading screen. + /// + public override void Update(GameTime gameTime, bool otherScreenHasFocus, + bool coveredByOtherScreen) + { + 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(); + } + } + + + /// + /// Draws the loading screen. + /// + public override void Draw(GameTime gameTime) + { + // 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.Font; + + 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 = Color.White * TransitionAlpha; + + // Draw the text. + spriteBatch.Begin(); + spriteBatch.DrawString(font, message, textPosition, color); + spriteBatch.End(); + } + } + + + #endregion + } +} diff --git a/axios/ScreenSystem/MainMenuScreen.cs b/axios/ScreenSystem/MainMenuScreen.cs new file mode 100644 index 0000000..7a60d8e --- /dev/null +++ b/axios/ScreenSystem/MainMenuScreen.cs @@ -0,0 +1,98 @@ +#region File Description +//----------------------------------------------------------------------------- +// MainMenuScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +#region Using Statements +using Microsoft.Xna.Framework; +#endregion + +namespace GameStateManagement +{ + /// + /// The main menu screen is the first thing displayed when the game starts up. + /// + class MainMenuScreen : MenuScreen + { + #region Initialization + + + /// + /// Constructor fills in the menu contents. + /// + public MainMenuScreen() + : base("Main Menu") + { + // Create our menu entries. + MenuEntry playGameMenuEntry = new MenuEntry("Play Game"); + MenuEntry optionsMenuEntry = new MenuEntry("Options"); + MenuEntry exitMenuEntry = new MenuEntry("Exit"); + + // Hook up menu event handlers. + playGameMenuEntry.Selected += PlayGameMenuEntrySelected; + optionsMenuEntry.Selected += OptionsMenuEntrySelected; + exitMenuEntry.Selected += OnCancel; + + // Add entries to the menu. + MenuEntries.Add(playGameMenuEntry); + MenuEntries.Add(optionsMenuEntry); + MenuEntries.Add(exitMenuEntry); + } + + + #endregion + + #region Handle Input + + + /// + /// Event handler for when the Play Game menu entry is selected. + /// + void PlayGameMenuEntrySelected(object sender, PlayerIndexEventArgs e) + { + LoadingScreen.Load(ScreenManager, true, e.PlayerIndex, + new GameplayScreen()); + } + + + /// + /// Event handler for when the Options menu entry is selected. + /// + void OptionsMenuEntrySelected(object sender, PlayerIndexEventArgs e) + { + ScreenManager.AddScreen(new OptionsMenuScreen(), e.PlayerIndex); + } + + + /// + /// When the user cancels the main menu, ask if they want to exit the sample. + /// + protected override void OnCancel(PlayerIndex playerIndex) + { + const string message = "Are you sure you want to exit this sample?"; + + MessageBoxScreen confirmExitMessageBox = new MessageBoxScreen(message); + + confirmExitMessageBox.Accepted += ConfirmExitMessageBoxAccepted; + + ScreenManager.AddScreen(confirmExitMessageBox, playerIndex); + } + + + /// + /// Event handler for when the user selects ok on the "are you sure + /// you want to exit" message box. + /// + void ConfirmExitMessageBoxAccepted(object sender, PlayerIndexEventArgs e) + { + ScreenManager.Game.Exit(); + } + + + #endregion + } +} diff --git a/axios/ScreenSystem/OptionsMenuScreen.cs b/axios/ScreenSystem/OptionsMenuScreen.cs new file mode 100644 index 0000000..8e549db --- /dev/null +++ b/axios/ScreenSystem/OptionsMenuScreen.cs @@ -0,0 +1,149 @@ +#region File Description +//----------------------------------------------------------------------------- +// OptionsMenuScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +#region Using Statements +using Microsoft.Xna.Framework; +#endregion + +namespace GameStateManagement +{ + /// + /// The options screen is brought up over the top of the main menu + /// screen, and gives the user a chance to configure the game + /// in various hopefully useful ways. + /// + class OptionsMenuScreen : MenuScreen + { + #region Fields + + MenuEntry ungulateMenuEntry; + MenuEntry languageMenuEntry; + MenuEntry frobnicateMenuEntry; + MenuEntry elfMenuEntry; + + enum Ungulate + { + BactrianCamel, + Dromedary, + Llama, + } + + static Ungulate currentUngulate = Ungulate.Dromedary; + + static string[] languages = { "C#", "French", "Deoxyribonucleic acid" }; + static int currentLanguage = 0; + + static bool frobnicate = true; + + static int elf = 23; + + #endregion + + #region Initialization + + + /// + /// Constructor. + /// + public OptionsMenuScreen() + : base("Options") + { + // Create our menu entries. + ungulateMenuEntry = new MenuEntry(string.Empty); + languageMenuEntry = new MenuEntry(string.Empty); + frobnicateMenuEntry = new MenuEntry(string.Empty); + elfMenuEntry = new MenuEntry(string.Empty); + + SetMenuEntryText(); + + MenuEntry back = new MenuEntry("Back"); + + // Hook up menu event handlers. + ungulateMenuEntry.Selected += UngulateMenuEntrySelected; + languageMenuEntry.Selected += LanguageMenuEntrySelected; + frobnicateMenuEntry.Selected += FrobnicateMenuEntrySelected; + elfMenuEntry.Selected += ElfMenuEntrySelected; + back.Selected += OnCancel; + + // Add entries to the menu. + MenuEntries.Add(ungulateMenuEntry); + MenuEntries.Add(languageMenuEntry); + MenuEntries.Add(frobnicateMenuEntry); + MenuEntries.Add(elfMenuEntry); + MenuEntries.Add(back); + } + + + /// + /// Fills in the latest values for the options screen menu text. + /// + void SetMenuEntryText() + { + ungulateMenuEntry.Text = "Preferred ungulate: " + currentUngulate; + languageMenuEntry.Text = "Language: " + languages[currentLanguage]; + frobnicateMenuEntry.Text = "Frobnicate: " + (frobnicate ? "on" : "off"); + elfMenuEntry.Text = "elf: " + elf; + } + + + #endregion + + #region Handle Input + + + /// + /// Event handler for when the Ungulate menu entry is selected. + /// + void UngulateMenuEntrySelected(object sender, PlayerIndexEventArgs e) + { + currentUngulate++; + + if (currentUngulate > Ungulate.Llama) + currentUngulate = 0; + + SetMenuEntryText(); + } + + + /// + /// Event handler for when the Language menu entry is selected. + /// + void LanguageMenuEntrySelected(object sender, PlayerIndexEventArgs e) + { + currentLanguage = (currentLanguage + 1) % languages.Length; + + SetMenuEntryText(); + } + + + /// + /// Event handler for when the Frobnicate menu entry is selected. + /// + void FrobnicateMenuEntrySelected(object sender, PlayerIndexEventArgs e) + { + frobnicate = !frobnicate; + + SetMenuEntryText(); + } + + + /// + /// Event handler for when the Elf menu entry is selected. + /// + void ElfMenuEntrySelected(object sender, PlayerIndexEventArgs e) + { + elf++; + + SetMenuEntryText(); + } + + + #endregion + } +} diff --git a/axios/ScreenSystem/PauseMenuScreen.cs b/axios/ScreenSystem/PauseMenuScreen.cs new file mode 100644 index 0000000..667ff71 --- /dev/null +++ b/axios/ScreenSystem/PauseMenuScreen.cs @@ -0,0 +1,79 @@ +#region File Description +//----------------------------------------------------------------------------- +// PauseMenuScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +#region Using Statements +using Microsoft.Xna.Framework; +#endregion + +namespace GameStateManagement +{ + /// + /// The pause menu comes up over the top of the game, + /// giving the player options to resume or quit. + /// + class PauseMenuScreen : MenuScreen + { + #region Initialization + + + /// + /// Constructor. + /// + public PauseMenuScreen() + : base("Paused") + { + // Create our menu entries. + MenuEntry resumeGameMenuEntry = new MenuEntry("Resume Game"); + MenuEntry quitGameMenuEntry = new MenuEntry("Quit Game"); + + // Hook up menu event handlers. + resumeGameMenuEntry.Selected += OnCancel; + quitGameMenuEntry.Selected += QuitGameMenuEntrySelected; + + // Add entries to the menu. + MenuEntries.Add(resumeGameMenuEntry); + MenuEntries.Add(quitGameMenuEntry); + } + + + #endregion + + #region Handle Input + + + /// + /// Event handler for when the Quit Game menu entry is selected. + /// + void QuitGameMenuEntrySelected(object sender, PlayerIndexEventArgs e) + { + const string message = "Are you sure you want to quit this game?"; + + MessageBoxScreen confirmQuitMessageBox = new MessageBoxScreen(message); + + confirmQuitMessageBox.Accepted += ConfirmQuitMessageBoxAccepted; + + ScreenManager.AddScreen(confirmQuitMessageBox, ControllingPlayer); + } + + + /// + /// Event handler for when the user selects ok on the "are you sure + /// you want to quit" message box. This uses the loading screen to + /// transition from the game back to the main menu screen. + /// + void ConfirmQuitMessageBoxAccepted(object sender, PlayerIndexEventArgs e) + { + LoadingScreen.Load(ScreenManager, false, null, new BackgroundScreen(), + new MainMenuScreen()); + } + + + #endregion + } +} diff --git a/axios/ScreenSystem/PhoneMainMenuScreen.cs b/axios/ScreenSystem/PhoneMainMenuScreen.cs new file mode 100644 index 0000000..3afcd8b --- /dev/null +++ b/axios/ScreenSystem/PhoneMainMenuScreen.cs @@ -0,0 +1,65 @@ +#region File Description +//----------------------------------------------------------------------------- +// PhoneMainMenuScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +using System; +using GameStateManagement; +using Microsoft.Xna.Framework; + +namespace GameStateManagement +{ + class PhoneMainMenuScreen : PhoneMenuScreen + { + public PhoneMainMenuScreen() + : base("Main Menu") + { + // Create a button to start the game + Button playButton = new Button("Play"); + playButton.Tapped += playButton_Tapped; + MenuButtons.Add(playButton); + + // Create two buttons to toggle sound effects and music. This sample just shows one way + // of making and using these buttons; it doesn't actually have sound effects or music + BooleanButton sfxButton = new BooleanButton("Sound Effects", true); + sfxButton.Tapped += sfxButton_Tapped; + MenuButtons.Add(sfxButton); + + BooleanButton musicButton = new BooleanButton("Music", true); + musicButton.Tapped += musicButton_Tapped; + MenuButtons.Add(musicButton); + } + + void playButton_Tapped(object sender, EventArgs e) + { + // When the "Play" button is tapped, we load the GameplayScreen + LoadingScreen.Load(ScreenManager, true, PlayerIndex.One, new GameplayScreen()); + } + + void sfxButton_Tapped(object sender, EventArgs e) + { + BooleanButton button = sender as BooleanButton; + + // In a real game, you'd want to store away the value of + // the button to turn off sounds here. :) + } + + void musicButton_Tapped(object sender, EventArgs e) + { + BooleanButton button = sender as BooleanButton; + + // In a real game, you'd want to store away the value of + // the button to turn off music here. :) + } + + protected override void OnCancel() + { + ScreenManager.Game.Exit(); + base.OnCancel(); + } + } +} diff --git a/axios/ScreenSystem/PhoneMenuScreen.cs b/axios/ScreenSystem/PhoneMenuScreen.cs new file mode 100644 index 0000000..85c88ae --- /dev/null +++ b/axios/ScreenSystem/PhoneMenuScreen.cs @@ -0,0 +1,149 @@ +#region File Description +//----------------------------------------------------------------------------- +// PhoneMenuScreen.cs +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#endregion + +using System; +using System.Collections.Generic; +using GameStateManagement; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Input.Touch; + +namespace GameStateManagement +{ + /// + /// Provides a basic base screen for menus on Windows Phone leveraging the Button class. + /// + class PhoneMenuScreen : GameScreen + { + List