public override void HandleInput(InputHelper input, GameTime gameTime)
{
if (input.IsNewKeyPress(Keys.Escape))
{
ExitScreen();
}
}
/// <summary>
/// Responds to user input, accepting or cancelling the message box.
/// </summary>
public override void HandleInput(InputHelper input, GameTime gameTime)
{
if (input.IsMenuSelect() || input.IsMenuCancel() ||
input.IsNewMouseButtonPress(MouseButtons.LeftButton))
{
ExitScreen();
}
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
if (input.KeyboardState.GetPressedKeys().Length > 0 ||
input.GamePadState.IsButtonDown(Buttons.A | Buttons.Start | Buttons.Back) ||
input.MouseState.LeftButton == ButtonState.Pressed)
{
_duration = TimeSpan.Zero;
}
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
Vector2 direction = Vector2.Zero;
if (input.KeyboardState.IsKeyDown(Keys.A))
{
direction += new Vector2(-1, 0);
}
if (input.KeyboardState.IsKeyDown(Keys.D))
{
direction += new Vector2(1, 0);
}
if (Players.ContainsKey(localIP) && Players[localIP].Action != "die")
{
if (Players[localIP].IsGrounded && (input.IsNewKeyPress(Keys.W) || input.IsNewKeyPress(Keys.Space)))
{
Players[localIP].Jump();
}
if (input.IsNewMouseButtonPress(MouseButtons.LeftButton))
{
Players[localIP].Attack();
}
Players[localIP].Move(gameTime, direction);
if (direction != Vector2.Zero)
{
Players[localIP].Direction = (int)direction.X;
}
}
else if (Players.ContainsKey(localIP))
{
timeSinceDeath += (float)gameTime.ElapsedGameTime.TotalSeconds;
if (timeSinceDeath >= TimeTilRespawn)
{
Players[localIP].Respawn();
timeSinceDeath = 0;
}
}
if (input.IsNewButtonPress(Buttons.Back) || input.IsNewKeyPress(Keys.Escape))
{
server.Shutdown("bye");
client.Shutdown("bye");
ExitScreen();
}
if (HasCursor)
{
HandleCursor(input);
}
base.HandleInput(input, gameTime);
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
if (input.IsNewButtonPress(Buttons.B) ||
input.IsNewMouseButtonPress(MouseButtons.RightButton) ||
input.IsNewKeyPress(Keys.Space))
{
_walker.Reverse();
}
base.HandleInput(input, gameTime);
}
/// <summary>
/// Constructs a new screen manager component.
/// </summary>
public ScreenManager(Game game)
: base(game)
{
// 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;
_contentManager = game.Content;
_contentManager.RootDirectory = "Content";
_input = new InputHelper(this);
_screens = new List<GameScreen>();
_screensToUpdate = new List<GameScreen>();
_transitions = new List<RenderTarget2D>();
}
/// <summary>
/// Responds to user input, changing the selected entry and accepting
/// or cancelling the menu.
/// </summary>
public override void HandleInput(InputHelper input, GameTime gameTime)
{
// Mouse or touch on a menu item
int hoverIndex = GetMenuEntryAt(input.Cursor);
if (hoverIndex > -1 && _menuEntries[hoverIndex].IsSelectable() && !_scrollLock)
{
_selectedEntry = hoverIndex;
}
else
{
_selectedEntry = -1;
}
_scrollSlider.Hover = false;
if (input.IsCursorValid)
{
_scrollUp.Collide(input.Cursor);
_scrollDown.Collide(input.Cursor);
_scrollSlider.Collide(input.Cursor);
}
else
{
_scrollUp.Hover = false;
_scrollDown.Hover = false;
_scrollLock = false;
}
// Accept or cancel the menu?
if (input.IsMenuSelect() && _selectedEntry != -1)
{
if (_menuEntries[_selectedEntry].IsExitItem())
{
ScreenManager.Game.Exit();
}
else if (_menuEntries[_selectedEntry].Screen == null)
{
//////////////////////////////////
//Navigate back to our old screen
//////////////////////////////////
if (_menuEntries[_selectedEntry].IsNoAction())
{
this.ExitScreen();
}
//////////////////////////////////
//Resume the game ie Pause Menu
//////////////////////////////////
if (_menuEntries[_selectedEntry].IsResumeGame())
{
//////////////////
//Resume the music
//////////////////
MusicHelper.ResumeSong();
this.ExitScreen();
}
//////////////////////////////////
//Restart Game
//////////////////////////////////
if (_menuEntries[_selectedEntry].IsRestart())
{
GameScreen[] scrs = ScreenManager.GetScreens();
PhysicsGameScreen game = scrs[scrs.Length - 2] as PhysicsGameScreen;
game.Reset();
this.ExitScreen();
}
//////////////////////////////////
//Go to Next Level
//////////////////////////////////
if (_menuEntries[_selectedEntry].IsNextLevel())
{
GameScreen[] scrs = ScreenManager.GetScreens();
PhysicsGameScreen game = scrs[scrs.Length - 2] as PhysicsGameScreen;
game.NextLevel();
this.ExitScreen();
}
//////////////////////////////////
//Navigate back to Main Menu
//////////////////////////////////
else if (_menuEntries[_selectedEntry].IsMainMenu())
{
GameScreen[] scrs = ScreenManager.GetScreens();
for (int i = scrs.Length - 1; i > 4; i--)
{
scrs[i].ExitScreen();
}
}
}
//////////////////////////////
//Play Default Music and game
//////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsDefaultMusic())
{
PhysicsGameScreen screen = _menuEntries[_selectedEntry].Screen as PhysicsGameScreen;
//////////////////////////////////////
//Check whether it is game or Freeplay
//////////////////////////////////////
if (_menuType == MenuType.FreePlayLevel)
{
//////////////////////////
//Force the FreePLay Level
//Index plus on becuase
//there is no option for
//tutorial
//////////////////////////
screen.GoToLevel(_selectedEntry + 1, 0);
}
else
{
screen.GoToLevel(_selectedEntry, 1);
}
MusicHelper.SetMusicType(MusicType.Default);
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
//////////////////////////////
//Play Custom Music and game
//////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsCustomMusic())
{
//MusicHelper.LoadSongFromLibrary();
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
///////////////////////////////////////
//Leave the playing Music and play game
///////////////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsBackgroundMuiscMuisc())
{
PhysicsGameScreen mscreen = _menuEntries[_selectedEntry].Screen as PhysicsGameScreen;
mscreen.GoToLevel(_selectedEntry,1);
MusicHelper.SetMusicType(MusicType.Background);
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
////////////////////////
//MainMenu GameMode Game
////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsGameModeGame())
{
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
////////////////////////////
//MainMenu GameMode FreePlay
////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsGameModeFreePlay())
{
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
//////////////////////////////
//Normal Add Screen
//////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null)
{
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
///////////////////////
//Use for tutorial
///////////////////////
if (_menuEntries[_selectedEntry].Screen is IDemoScreen)
{
ScreenManager.AddScreen(
new MessageBoxScreen((_menuEntries[_selectedEntry].Screen as IDemoScreen).GetDetails()));
}
}
else if (input.IsMenuCancel())
{
//////////////////////////
//Main Menu
//////////////////////////
if (_menuType == MenuType.MainMenu)
{
ScreenManager.Game.Exit();
}
else if (_menuType != MenuType.MainMenu)
{
if (_menuType == MenuType.Pause)
{
MusicHelper.ResumeSong();
}
this.ExitScreen();
}
}
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);
}
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
Keys[] pressedKeys = input.KeyboardState.GetPressedKeys();
float step = (float)0.75;
if(pressedKeys.Any(x => x == Keys.Up))
{
this.gamePad2.Position = new Vector2((float)(this.gamePad2.Position.X), this.gamePad2.Position.Y - step);
}
else if (pressedKeys.Any(x => x == Keys.Down))
{
this.gamePad2.Position = new Vector2((float)(this.gamePad2.Position.X), this.gamePad2.Position.Y + step);
}
if(pressedKeys.Any(x => x == Keys.W))
{
this.gamePad1.Position = new Vector2((float)(this.gamePad1.Position.X), this.gamePad1.Position.Y - step);
}
else if (pressedKeys.Any(x => x == Keys.S))
{
this.gamePad1.Position = new Vector2((float)(this.gamePad1.Position.X), this.gamePad1.Position.Y + step);
}
base.HandleInput(input, gameTime);
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
if (input.VirtualState.ThumbSticks.Left.X > 0.5f)
{
_acceleration = Math.Min(_acceleration + (float)(2.0 * gameTime.ElapsedGameTime.TotalSeconds), 1f);
}
else if (input.VirtualState.ThumbSticks.Left.X < -0.5f)
{
_acceleration = Math.Max(_acceleration - (float)(2.0 * gameTime.ElapsedGameTime.TotalSeconds), -1f);
}
else if (input.VirtualState.Buttons.A == ButtonState.Pressed)
{
_acceleration = 0f;
}
else
{
_acceleration -= Math.Sign(_acceleration) * (float)(2.0 * gameTime.ElapsedGameTime.TotalSeconds);
}
base.HandleInput(input, gameTime);
}
private void HandleUserAgent(InputHelper input)
{
Vector2 force = _agentForce * new Vector2(input.GamePadState.ThumbSticks.Right.X,
-input.GamePadState.ThumbSticks.Right.Y);
float torque = _agentTorque * (input.GamePadState.Triggers.Right - input.GamePadState.Triggers.Left);
_userAgent.ApplyForce(force);
_userAgent.ApplyTorque(torque);
float forceAmount = _agentForce * 0.6f;
force = Vector2.Zero;
torque = 0;
if (input.KeyboardState.IsKeyDown(Keys.A))
{
force += new Vector2(-forceAmount, 0);
}
if (input.KeyboardState.IsKeyDown(Keys.S))
{
force += new Vector2(0, forceAmount);
}
if (input.KeyboardState.IsKeyDown(Keys.D))
{
force += new Vector2(forceAmount, 0);
}
if (input.KeyboardState.IsKeyDown(Keys.W))
{
force += new Vector2(0, -forceAmount);
}
if (input.KeyboardState.IsKeyDown(Keys.Q))
{
torque -= _agentTorque;
}
if (input.KeyboardState.IsKeyDown(Keys.E))
{
torque += _agentTorque;
}
_userAgent.ApplyForce(force);
_userAgent.ApplyTorque(torque);
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
// Control debug view
if (input.IsNewButtonPress(Buttons.Start))
{
EnableOrDisableFlag(DebugViewFlags.Shape);
EnableOrDisableFlag(DebugViewFlags.DebugPanel);
EnableOrDisableFlag(DebugViewFlags.PerformanceGraph);
EnableOrDisableFlag(DebugViewFlags.Joint);
EnableOrDisableFlag(DebugViewFlags.ContactPoints);
EnableOrDisableFlag(DebugViewFlags.ContactNormals);
EnableOrDisableFlag(DebugViewFlags.Controllers);
}
if (input.IsNewKeyPress(Keys.F1))
{
EnableOrDisableFlag(DebugViewFlags.Shape);
}
if (input.IsNewKeyPress(Keys.F2))
{
EnableOrDisableFlag(DebugViewFlags.DebugPanel);
EnableOrDisableFlag(DebugViewFlags.PerformanceGraph);
}
if (input.IsNewKeyPress(Keys.F3))
{
EnableOrDisableFlag(DebugViewFlags.Joint);
}
if (input.IsNewKeyPress(Keys.F4))
{
EnableOrDisableFlag(DebugViewFlags.ContactPoints);
EnableOrDisableFlag(DebugViewFlags.ContactNormals);
}
if (input.IsNewKeyPress(Keys.F5))
{
EnableOrDisableFlag(DebugViewFlags.PolygonPoints);
}
if (input.IsNewKeyPress(Keys.F6))
{
EnableOrDisableFlag(DebugViewFlags.Controllers);
}
if (input.IsNewKeyPress(Keys.F7))
{
EnableOrDisableFlag(DebugViewFlags.CenterOfMass);
}
if (input.IsNewKeyPress(Keys.F8))
{
EnableOrDisableFlag(DebugViewFlags.AABB);
}
if (input.IsNewButtonPress(Buttons.Back) || input.IsNewKeyPress(Keys.Escape))
{
ExitScreen();
}
if (HasCursor)
{
HandleCursor(input);
}
if (_userAgent != null)
{
HandleUserAgent(input);
}
if (EnableCameraControl)
{
// HandleCamera(input, gameTime);
}
base.HandleInput(input, gameTime);
}
private void HandleCamera(InputHelper input, GameTime gameTime)
{
Vector2 camMove = Vector2.Zero;
if (input.KeyboardState.IsKeyDown(Keys.Up))
{
camMove.Y -= 10f * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
if (input.KeyboardState.IsKeyDown(Keys.Down))
{
camMove.Y += 10f * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
if (input.KeyboardState.IsKeyDown(Keys.Left))
{
camMove.X -= 10f * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
if (input.KeyboardState.IsKeyDown(Keys.Right))
{
camMove.X += 10f * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
if (input.KeyboardState.IsKeyDown(Keys.PageUp))
{
Camera.Zoom += 5f * (float)gameTime.ElapsedGameTime.TotalSeconds * Camera.Zoom / 20f;
}
if (input.KeyboardState.IsKeyDown(Keys.PageDown))
{
Camera.Zoom -= 5f * (float)gameTime.ElapsedGameTime.TotalSeconds * Camera.Zoom / 20f;
}
if (camMove != Vector2.Zero)
{
Camera.MoveCamera(camMove);
}
if (input.IsNewKeyPress(Keys.Home))
{
Camera.ResetCamera();
}
}
private void HandleCursor(InputHelper input)
{
Vector2 position = Camera.ConvertScreenToWorld(input.Cursor);
if ((input.IsNewButtonPress(Buttons.A) ||
input.IsNewMouseButtonPress(MouseButtons.LeftButton)) &&
_fixedMouseJoint == null)
{
Fixture savedFixture = World.TestPoint(position);
if (savedFixture != null)
{
Body body = savedFixture.Body;
_fixedMouseJoint = new FixedMouseJoint(body, position);
_fixedMouseJoint.MaxForce = 1000.0f * body.Mass;
World.AddJoint(_fixedMouseJoint);
body.Awake = true;
}
}
if ((input.IsNewButtonRelease(Buttons.A) ||
input.IsNewMouseButtonRelease(MouseButtons.LeftButton)) &&
_fixedMouseJoint != null)
{
World.RemoveJoint(_fixedMouseJoint);
_fixedMouseJoint = null;
}
if (_fixedMouseJoint != null)
{
_fixedMouseJoint.WorldAnchorB = position;
}
}
private void HandleCursor(InputHelper input)
{
Vector2 position = Camera.ConvertScreenToWorld(input.Cursor);
}
/// <summary>
/// Responds to user input, changing the selected entry and accepting
/// or cancelling the menu.
/// </summary>
public override void HandleInput(InputHelper input, GameTime gameTime)
{
// Mouse or touch on a menu item
int hoverIndex = GetMenuEntryAt(input.Cursor);
if (hoverIndex > -1 && _menuEntries[hoverIndex].IsSelectable() && !_scrollLock)
{
_selectedEntry = hoverIndex;
}
else
{
_selectedEntry = -1;
}
_scrollSlider.Hover = false;
if (input.IsCursorValid)
{
_scrollUp.Collide(input.Cursor);
_scrollDown.Collide(input.Cursor);
_scrollSlider.Collide(input.Cursor);
}
else
{
_scrollUp.Hover = false;
_scrollDown.Hover = false;
_scrollLock = false;
}
// Accept or cancel the menu?
if (input.IsMenuSelect() && _selectedEntry != -1)
{
if (_menuEntries[_selectedEntry].IsExitItem())
{
ScreenManager.Game.Exit();
}
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()));
}
}
}
else if (input.IsMenuCancel())
{
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);
}
}
/// <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)
{
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
Keys[] pressedKeys = input.KeyboardState.GetPressedKeys();
if(pressedKeys.Any(x => x == Keys.Up))
{
this.MoveVertical(gamePad2, -step);
//this.gamePad2.Position = new Vector2((float)(this.gamePad2.Position.X), Math.Max(this.gamePad2.Position.Y - step, MinTop));
}
else if (pressedKeys.Any(x => x == Keys.Down))
{
//this.gamePad2.Position = new Vector2((float)(this.gamePad2.Position.X), Math.Min(this.gamePad2.Position.Y + step, MaxTop));
this.MoveVertical(gamePad2, +step);
}
if(pressedKeys.Any(x => x == Keys.W))
{
this.MoveVertical(gamePad1, -step);
}
else if (pressedKeys.Any(x => x == Keys.S))
{
this.MoveVertical(gamePad1, +step);
//this.gamePad1.Position = new Vector2((float)(this.gamePad1.Position.X), Math.Min(this.gamePad1.Position.Y + step, MaxTop));
}
if (pressedKeys.Any(x => x == Keys.Enter) && !geometryAdded)
{
geometryAdded = true;
var verts = new Vertices { new Vector2(-2, -2), new Vector2(-2, 2), new Vector2(2, 2), new Vector2(2, -2) };
var geo = BodyFactory.CreateCompoundPolygon(World, BayazitDecomposer.ConvexPartition(verts), 1f, new Vector2(-3));
geo.IsStatic = true;
geo.Restitution = 1f;
geo.Friction = 0f;
var sprite = new Sprite(ScreenManager.Assets.TextureFromShape(geo.FixtureList[0].Shape, MaterialType.Dots, Color.SandyBrown, 0.8f));
dymanicShit.Add(new BodySprite { Body = geo, Sprite = sprite });
}
base.HandleInput(input, gameTime);
}
/// <summary>
/// Responds to user input, changing the selected entry and accepting
/// or cancelling the menu.
/// </summary>
public override void HandleInput(InputHelper input, GameTime gameTime)
{
// Mouse or touch on a menu item
int hoverIndex = GetMenuEntryAt(input.Cursor);
if (hoverIndex > -1 && _menuEntries[hoverIndex].IsSelectable() && !_scrollLock)
{
_selectedEntry = hoverIndex;
}
else
{
_selectedEntry = -1;
}
_scrollSlider.Hover = false;
if (input.IsCursorValid)
{
_scrollUp.Collide(input.Cursor);
_scrollDown.Collide(input.Cursor);
_scrollSlider.Collide(input.Cursor);
}
else
{
_scrollUp.Hover = false;
_scrollDown.Hover = false;
_scrollLock = false;
}
// Accept or cancel the menu?
if (input.IsMenuSelect() && _selectedEntry != -1)
{
if (_menuEntries[_selectedEntry].IsExitItem())
{
ScreenManager.Game.Exit();
}
else if (_menuEntries[_selectedEntry].Screen == null)
{
//////////////////////////////////
//Navigate back to our old screen
//////////////////////////////////
if (_menuEntries[_selectedEntry].IsNoAction())
{
this.ExitScreen();
}
//////////////////////////////////
//Restart Game
//////////////////////////////////
if (_menuEntries[_selectedEntry].IsRestart())
{
GameScreen[] scrs = ScreenManager.GetScreens();
PhysicsGameScreen game = scrs[scrs.Length - 2] as PhysicsGameScreen;
game.Reset();
this.ExitScreen();
}
//////////////////////////////////
//Go to Next Level
//////////////////////////////////
if (_menuEntries[_selectedEntry].IsNextLevel())
{
GameScreen[] scrs = ScreenManager.GetScreens();
PhysicsGameScreen game = scrs[scrs.Length - 2] as PhysicsGameScreen;
game.NextLevel();
this.ExitScreen();
}
//////////////////////////////////
//Navigate back to Main Menu
//////////////////////////////////
else if (_menuEntries[_selectedEntry].IsMainMenu())
{
GameScreen[] scrs = ScreenManager.GetScreens();
for (int i = scrs.Length - 1; i > 5; i--)
{
scrs[i].ExitScreen();
}
}
}
//////////////////////////////
//Play Default Music and game
//////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsDefaultMusic())
{
MusicHelper.Play();
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
//////////////////////////////
//Play Custom Music and game
//////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsCustomMusic())
{
MusicHelper.Play();
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
//////////////////////////////
//Go to specfic Screen
//////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null &&
_menuEntries[_selectedEntry].IsGoToLevel())
{
PhysicsGameScreen game = _menuEntries[_selectedEntry].Screen as PhysicsGameScreen;
game.GoToLevel(_selectedEntry);
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
//////////////////////////////
//Normal Add Screen
//////////////////////////////
else if (_menuEntries[_selectedEntry].Screen != null)
{
ScreenManager.AddScreen(_menuEntries[_selectedEntry].Screen);
}
///////////////////////
//Use for tutorial
///////////////////////
if (_menuEntries[_selectedEntry].Screen is IDemoScreen)
{
ScreenManager.AddScreen(
new MessageBoxScreen((_menuEntries[_selectedEntry].Screen as IDemoScreen).GetDetails()));
}
}
else if (input.IsMenuCancel())
{
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);
}
}
/// <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)
{
}
public override void HandleInput(InputHelper input, GameTime gameTime)
{
if (input.IsNewMouseButtonPress(MouseButtons.RightButton) ||
input.IsNewButtonPress(Buttons.B))
{
Vector2 cursorPos = Camera.ConvertScreenToWorld(input.Cursor);
Vector2 min = cursorPos - new Vector2(10, 10);
Vector2 max = cursorPos + new Vector2(10, 10);
AABB aabb = new AABB(ref min, ref max);
World.QueryAABB(fixture =>
{
Vector2 fv = fixture.Body.Position - cursorPos;
fv.Normalize();
fv *= 40;
fixture.Body.ApplyLinearImpulse(ref fv);
return true;
}, ref aabb);
}
base.HandleInput(input, gameTime);
}
