#region File Description
#endregion
using
System;
using
Microsoft.Xna.Framework;
using
Microsoft.Xna.Framework.Input.Touch;
namespace
FarseerPhysics.SamplesFramework
{
/// <summary>
/// Enum describes the screen transition state.
/// </summary>
public
enum
ScreenState
{
TransitionOn,
Active,
TransitionOff,
Hidden,
}
/// <summary>
/// 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.
/// For instance the main menu, the options menu, the "are you sure you
/// want to quit" message box, and the main game itself are all implemented
/// as screens.
/// </summary>
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
; }
/// <summary>
/// Normally when one screen is brought up over the top of another,
/// the first screen will transition off to make room for the new
/// one. This property indicates whether the screen is only a small
/// popup, in which case screens underneath it do not need to bother
/// transitioning off.
/// </summary>
public
bool
IsPopup {
get
;
protected
set
; }
/// <summary>
/// Indicates how long the screen takes to
/// transition on when it is activated.
/// </summary>
public
TimeSpan TransitionOnTime {
get
;
protected
set
; }
/// <summary>
/// Indicates how long the screen takes to
/// transition off when it is deactivated.
/// </summary>
public
TimeSpan TransitionOffTime {
get
;
protected
set
; }
/// <summary>
/// Gets the current position of the screen transition, ranging
/// from zero (fully active, no transition) to one (transitioned
/// fully off to nothing).
/// </summary>
public
float
TransitionPosition {
get
;
protected
set
; }
/// <summary>
/// Gets the current alpha of the screen transition, ranging
/// from 1 (fully active, no transition) to 0 (transitioned
/// fully off to nothing).
/// </summary>
public
float
TransitionAlpha
{
get
{
return
1f - TransitionPosition; }
}
/// <summary>
/// Gets the current screen transition state.
/// </summary>
public
ScreenState ScreenState {
get
;
protected
set
; }
/// <summary>
/// There are two possible reasons why a screen might be transitioning
/// off. It could be temporarily going away to make room for another
/// screen that is on top of it, or it could be going away for good.
/// This property indicates whether the screen is exiting for real:
/// if set, the screen will automatically remove itself as soon as the
/// transition finishes.
/// </summary>
public
bool
IsExiting {
get
;
protected
internal
set
; }
public
bool
AlwaysHasFocus =
false
;
/// <summary>
/// Checks whether this screen is active and can respond to user input.
/// </summary>
public
bool
IsActive
{
get
{
return
!_otherScreenHasFocus &&
(ScreenState == ScreenState.TransitionOn ||
ScreenState == ScreenState.Active);
}
}
/// <summary>
/// Gets the manager that this screen belongs to.
/// </summary>
public
ScreenManager ScreenManager {
get
;
internal
set
; }
/// <summary>
/// Gets the gestures the screen is interested in. Screens should be as specific
/// as possible with gestures to increase the accuracy of the gesture engine.
/// For example, most menus only need Tap or perhaps Tap and VerticalDrag to operate.
/// These gestures are handled by the ScreenManager when screens change and
/// all gestures are placed in the InputState passed to the HandleInput method.
/// </summary>
public
GestureType EnabledGestures
{
get
{
return
_enabledGestures; }
protected
set
{
_enabledGestures = value;
if
(ScreenState == ScreenState.Active)
{
TouchPanel.EnabledGestures = value;
}
}
}
/// <summary>
/// Load graphics content for the screen.
/// </summary>
public
virtual
void
LoadContent()
{
}
/// <summary>
/// Unload content for the screen.
/// </summary>
public
virtual
void
UnloadContent()
{
}
/// <summary>
/// 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.
/// </summary>
public
virtual
void
Update(GameTime gameTime,
bool
otherScreenHasFocus,
bool
coveredByOtherScreen)
{
_otherScreenHasFocus = otherScreenHasFocus;
if
(IsExiting)
{
ScreenState = ScreenState.TransitionOff;
if
(!UpdateTransition(gameTime, TransitionOffTime, 1))
{
ScreenManager.RemoveScreen(
this
);
}
}
else
if
(coveredByOtherScreen)
{
if
(UpdateTransition(gameTime, TransitionOffTime, 1))
{
ScreenState = ScreenState.TransitionOff;
}
else
{
ScreenState = ScreenState.Hidden;
}
}
else
{
if
(UpdateTransition(gameTime, TransitionOnTime, -1))
{
ScreenState = ScreenState.TransitionOn;
}
else
{
ScreenState = ScreenState.Active;
}
}
}
/// <summary>
/// Helper for updating the screen transition position.
/// </summary>
private
bool
UpdateTransition(GameTime gameTime, TimeSpan time,
int
direction)
{
float
transitionDelta;
if
(time == TimeSpan.Zero)
{
transitionDelta = 1f;
}
else
{
transitionDelta = (
float
)(gameTime.ElapsedGameTime.TotalMilliseconds /
time.TotalMilliseconds);
}
TransitionPosition += transitionDelta * direction;
if
(((direction < 0) && (TransitionPosition <= 0)) ||
((direction > 0) && (TransitionPosition >= 1)))
{
TransitionPosition = MathHelper.Clamp(TransitionPosition, 0, 1);
return
false
;
}
return
true
;
}
/// <summary>
/// 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.
/// </summary>
public
virtual
void
HandleInput(InputHelper input, GameTime gameTime)
{
}
/// <summary>
/// This is called when the screen should draw itself.
/// </summary>
public
virtual
void
Draw(GameTime gameTime)
{
}
/// <summary>
/// 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.
/// </summary>
public
virtual
void
ExitScreen()
{
if
(TransitionOffTime == TimeSpan.Zero &&
this
.TransitionPosition == 0 &&
this
.TransitionAlpha == 1)
{
ScreenManager.RemoveScreen(
this
);
}
else
{
IsExiting =
true
;
}
}
}
}