/// <summary>
/// Constructs a new screen manager component.
/// </summary>
public ScreenManager(Game game, InputState inputState)
: base(game)
{
input = inputState;
// we must set EnabledGestures before we can query for them, but
// we don't assume the game wants to read them.
TouchPanel.EnabledGestures = GestureType.None;
}
public override void HandleInput(InputState input)
{
// Look up inputs for the active player profile.
PlayerIndex playerIndex = new PlayerIndex();
if (input.IsNewKeyPress(Keys.Space, null, out playerIndex))
{
onCancel();
}
base.HandleInput(input);
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
config.Initialize();
InputState inputState = new InputState(true, config);
mainCamera = new Camera();
mainCamera.SubscribeToHandler(inputState);
// Create the screen manager component.
screenManager = new ScreenManager(this, inputState);
graphics.PreferredBackBufferWidth = 1080;
graphics.PreferredBackBufferHeight = 720;
//Resolution.Init(ref graphics);
mainCamera.Init(ref graphics);
// Change Virtual Resolution
bool b;
Point p = config.GetStartUpResolution(out b); //used out to get all three SetRes params
//Resolution.SetResolution(p.X, p.Y, b);
mainCamera.SetResolution(p.X, p.Y, b);
p = config.GetStartUpVResolution();
//Resolution.SetVirtualResolution(p.X, p.Y);
mainCamera.InitializeView(p.X, p.Y, 50, 50);
Content.RootDirectory = "Content";
Components.Add(screenManager);
/*
Components.Add(screenManager);
// Activate the first screens.
screenManager.AddScreen(new BackgroundScreen(), null);
screenManager.AddScreen(new MainMenuScreen(), null);
*/
base.Initialize();
}
/// <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(InputState input)
{
}
/// <summary>
/// Responds to user input, changing the selected entry and accepting
/// or cancelling the menu.
/// </summary>
public override void HandleInput(InputState input)
{
// Move to the previous menu entry?
if (input.IsMenuUp(ControllingPlayer))
{
selectedEntry--;
if (selectedEntry < 0)
selectedEntry = menuEntries.Count - 1;
}
// Move to the next menu entry?
if (input.IsMenuDown(ControllingPlayer))
{
selectedEntry++;
if (selectedEntry >= menuEntries.Count)
selectedEntry = 0;
}
// Accept or cancel the menu? We pass in our ControllingPlayer, which may
// either be null (to accept input from any player) or a specific index.
// If we pass a null controlling player, the InputState helper returns to
// us which player actually provided the input. We pass that through to
// OnSelectEntry and OnCancel, so they can tell which player triggered them.
PlayerIndex playerIndex;
if (input.IsMenuSelect(ControllingPlayer, out playerIndex))
{
OnSelectEntry(selectedEntry, playerIndex);
}
else if (input.IsMenuCancel(ControllingPlayer, out playerIndex))
{
OnCancel(playerIndex);
}
}
/// <summary>
/// Responds to user input, accepting or cancelling the message box.
/// </summary>
public override void HandleInput(InputState input)
{
PlayerIndex playerIndex;
// 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 (input.IsMenuSelect(ControllingPlayer, out playerIndex))
{
// Raise the accepted event, then exit the message box.
if (Accepted != null)
Accepted(this, new PlayerIndexEventArgs(playerIndex));
ExitScreen();
}
else if (input.IsMenuCancel(ControllingPlayer, out playerIndex))
{
// Raise the cancelled event, then exit the message box.
if (Cancelled != null)
Cancelled(this, new PlayerIndexEventArgs(playerIndex));
ExitScreen();
}
}
public void SubscribeToHandler(InputState iState)
{
//em.PlaySound += new EventManager.SoundEventHandler(EventFired);
// lambda expression
iState.Controls.FireInputEvent += (sender, firedEvent) =>
{
//senders.Add(sender);
//eventArgs.Add(firedEvent);
/*
* So I wanted this to be quick, a simple switch will check on at most N items,
* where N is the number of buttons assigned a command. This should never exceed 20,
* mostly because I f*****g say so, but also because even the most complicated RTS or RPG
* can be done elegantly so as to not force the player to remember an ungodly amount of
* commands. In any case, this area is definitely a candidate for future overhaul pending
* future analysis.
*/
switch(firedEvent.Command)
{
case Controls.Commands.GameUp :
position.Y += (int)scrollSpeedY;
//viewPort.Y += (int)scrollSpeedY;
//direction = new Vector3(direction.X, direction.Y + (int)scrollSpeedY, 0);
_dirtyMatrix = true;
break;
case Controls.Commands.GameLeft :
position.X += (int)scrollSpeedX;
//viewPort.X += (int)scrollSpeedX;
//direction = new Vector3(direction.X + (int)scrollSpeedX, direction.Y, 0);
_dirtyMatrix = true;
break;
case Controls.Commands.GameDown :
position.Y -= (int)scrollSpeedY;
//viewPort.Y -= (int)scrollSpeedY;
//direction = new Vector3(direction.X, direction.Y - (int)scrollSpeedY, 0);
_dirtyMatrix = true;
break;
case Controls.Commands.GameRight :
position.X -= (int)scrollSpeedX;
//viewPort.X -= (int)scrollSpeedX;
//direction = new Vector3(direction.X - (int)scrollSpeedX, direction.Y, 0);
_dirtyMatrix = true;
break;
case Controls.Commands.RotateCC:
rotation += rotationAmt;
_dirtyMatrix = true;
break;
case Controls.Commands.RotateCW:
rotation -= rotationAmt;
_dirtyMatrix = true;
break;
case Controls.Commands.Action3:
rotation = 0;
_dirtyMatrix = true;
break;
case Controls.Commands.ZoomIn:
SetVirtualResolution(_VWidth + (int)(zoomAmount * getVirtualAspectRatio()), _VHeight + (int)zoomAmount);
_dirtyMatrix = true;
break;
case Controls.Commands.ZoomOut:
SetVirtualResolution(_VWidth - (int)(zoomAmount * getVirtualAspectRatio()), _VHeight - (int)zoomAmount);
_dirtyMatrix = true;
break;
}
//if(_dirtyMatrix)
};
}
/// <summary>
/// Lets the game respond to player input. Unlike the Update method,
/// this will only be called when the gameplay screen is active.
/// </summary>
public override void HandleInput(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];
if (input.IsPauseGame(ControllingPlayer) || gamePadDisconnected)
{
ScreenManager.AddScreen(new PauseMenuScreen(this.game), ControllingPlayer);
}
else
{
/*
// Otherwise move the background to scroll
Vector2 movement = Vector2.Zero;
if (keyboardState.IsKeyDown(Keys.A))
movement.X--;
if (keyboardState.IsKeyDown(Keys.D))
movement.X++;
if (keyboardState.IsKeyDown(Keys.W))
movement.Y--;
if (keyboardState.IsKeyDown(Keys.S))
movement.Y++;
Vector2 thumbstick = gamePadState.ThumbSticks.Left;
movement.X += thumbstick.X;
movement.Y -= thumbstick.Y;
if (movement.Length() > 1)
movement.Normalize();
//playerPosition += movement * 2;
singlePlayerVP.X += (int)movement.X * 2;
singlePlayerVP.Y += (int)movement.Y * 2;
*/
}
}
