public void Update(GamePadState pad) { if (pad.IsButtonDown(Buttons.LeftThumbstickDown) && !oldPad.IsButtonDown(Buttons.LeftThumbstickDown)) { if (current < 3) { current++; } } if (pad.IsButtonDown(Buttons.LeftThumbstickUp) && !oldPad.IsButtonDown(Buttons.LeftThumbstickUp)) { if (current > 1) { current--; } } if (pad.IsButtonDown(Buttons.A) && oldPad.IsButtonUp(Buttons.A)) { if (current == 1) { FirstGame.start = true; } else if (current == 3) { FirstGame.exit = true; } } oldPad = pad; }
// Adds an attack when the attack button is pressed accompanied by sound and animation public static void AttackAdd(ContentManager Content, Player ninja, List<PlayerAttack> ninjaAttacks, KeyboardState presentKey, KeyboardState pastKey, GamePadState pressentButton, GamePadState pastButton) { if (presentKey.IsKeyDown(Keys.Space) && pastKey.IsKeyUp(Keys.Space) || pressentButton.IsButtonDown(Buttons.A) && pastButton.IsButtonUp(Buttons.A)) { // if the attack button is pressed a new attack will be added to the list ninjaAttacks.Add(new PlayerAttack(Content.Load<Texture2D>("Images\\Attack"), new Vector2(ninja.PositionX + (int)(ninja.Texture.Width * 0.8), ninja.PositionY + (int)(ninja.Texture.Height / 2.25)))); // A sound effect will be played each time we press the attack button ninja.PlaySound(); } // The animation texture of the character will change with each attack if (presentKey.IsKeyDown(Keys.Space) || pressentButton.IsButtonDown(Buttons.A)) { ninja.Texture = Content.Load<Texture2D>("Images\\NinjaFrame1-2"); } else { ninja.Texture = Content.Load<Texture2D>("Images\\NinjaFrame1-1"); } }
public void Update() { gamePadState = GamePad.GetState(PlayerIndex.One); bool foundInput = false; if (gamePadState.IsButtonDown(Buttons.Start) && !startPressed) { startPressed = true; new StartButtonCommand().Execute(); } else if (gamePadState.IsButtonUp(Buttons.Start) && startPressed) { startPressed = false; } if (playableObject.IsEnteringPipe || playableObject.IsExitingPipe) { new MarioNoInputCommand(playableObject).Execute(); } else { if (gamePadState.IsButtonDown(Buttons.A) && !jumpPressed) { jumpPressed = true; new MarioJumpCommand(playableObject).Execute(); foundInput = true; } else if (gamePadState.IsButtonDown(Buttons.A)) { foundInput = true; } else if (gamePadState.IsButtonUp(Buttons.A) && jumpPressed) { jumpPressed = false; } if (gamePadState.IsButtonDown(Buttons.B)) { playableObject.MaxHorizontalVelocity = GameValues.MarioRunningSpeed; new MarioRunCommand(playableObject).Execute(); } else { playableObject.MaxHorizontalVelocity = GameValues.MarioWalkingSpeed; } foreach (KeyValuePair<Buttons, ICommand> item in buttonMap) { if (gamePadState.IsButtonDown(item.Key)) { item.Value.Execute(); foundInput = true; } } if (!foundInput) { new MarioNoInputCommand(playableObject).Execute(); } } }
public static void updateSingleplayer() { prevGamepad = currGamepad; currGamepad = GamePad.GetState(PlayerIndex.One); Vector2 moveVec = new Vector2(0, 0); if (currGamepad.IsButtonDown(Buttons.DPadUp)) moveVec += new Vector2(0, -speed); if (currGamepad.IsButtonDown(Buttons.DPadLeft)) moveVec += new Vector2(-speed, 0); if (currGamepad.IsButtonDown(Buttons.DPadDown)) moveVec += new Vector2(0, speed); if (currGamepad.IsButtonDown(Buttons.DPadRight)) moveVec += new Vector2(speed, 0); if (isClicked(Buttons.A) && !isJumping) isJumping = true; if (isJumping && !limitReached) { moveVec += new Vector2(0, -speed); test += speed; if (test == limit) limitReached = true; } else if (limitReached) { moveVec -= new Vector2(0, -speed); test -= speed; if (test == 0) { limitReached = false; isJumping = false; } } Camera2D.movePosition(moveVec); }
public void ProcessController() { keyState = Keyboard.GetState(); padState = GamePad.GetState(Microsoft.Xna.Framework.PlayerIndex.One); Actor hero = (Actor)game.Hero; /* * GamePad inputs */ //Moving if (padState.IsButtonDown(Buttons.LeftThumbstickLeft) || keyState.IsKeyDown(Keys.Left)) { hero.Pos.X -= 1.5f; hero.NextPosture(ActorDirection.Left); } if (padState.IsButtonDown(Buttons.LeftThumbstickRight) || keyState.IsKeyDown(Keys.Right)) { hero.Pos.X += 1.5f; hero.NextPosture(ActorDirection.Right); } //Jump if (padState.IsButtonDown(Buttons.LeftThumbstickUp)) { } if (padState.IsButtonDown(Buttons.LeftThumbstickDown)) { } }
public static void FireCannons(GamePadState gs, GamePadState previousGamePadState, Player player, GameTime gameTime) { if (gs.IsButtonDown(actionKeys[Action.FireLeftCannon])) { player.FireLeftCannons(gameTime); } if (gs.IsButtonDown(actionKeys[Action.FireRightCannon])) { player.FireRightCannons(gameTime); } }
/// <summary> /// Gets the current direction from a game pad and keyboard. /// </summary> public static Buttons FromInput(GamePadState gamePad, KeyboardState keyboard) { Buttons direction = None; // Get vertical direction. if (gamePad.IsButtonDown(Buttons.DPadUp) || gamePad.IsButtonDown(Buttons.LeftThumbstickUp) || keyboard.IsKeyDown(Keys.Up)) { direction |= Up; } else if (gamePad.IsButtonDown(Buttons.DPadDown) || gamePad.IsButtonDown(Buttons.LeftThumbstickDown) || keyboard.IsKeyDown(Keys.Down)) { direction |= Down; } // Comebine with horizontal direction. if (gamePad.IsButtonDown(Buttons.DPadLeft) || gamePad.IsButtonDown(Buttons.LeftThumbstickLeft) || keyboard.IsKeyDown(Keys.Left)) { direction |= Left; } else if (gamePad.IsButtonDown(Buttons.DPadRight) || gamePad.IsButtonDown(Buttons.LeftThumbstickRight) || keyboard.IsKeyDown(Keys.Right)) { direction |= Right; } return direction; }
/// <summary> /// Generates a GamePadState based on the touch input provided (as applied to the on screen controls) and the gamepad state /// </summary> public GamePadState GetState(TouchCollection touchState, GamePadState gpState) { //Work out what buttons are pressed based on the touchState Buttons buttonsPressed = 0; foreach (TouchLocation touch in touchState) { if (touch.State == TouchLocationState.Moved || touch.State == TouchLocationState.Pressed) { //Scale the touch position to be in _baseScreenSize coordinates Vector2 pos = touch.Position; Vector2.Transform(ref pos, ref globalTransformation, out pos); if (pos.X < 128) buttonsPressed |= Buttons.DPadLeft; else if (pos.X < 256) buttonsPressed |= Buttons.DPadRight; else if (pos.X >= baseScreenSize.X - 128) buttonsPressed |= Buttons.A; } } //Combine the buttons of the real gamepad GamePadButtons gpButtons = gpState.Buttons; buttonsPressed |= (gpButtons.A == ButtonState.Pressed ? Buttons.A : 0); buttonsPressed |= (gpButtons.B == ButtonState.Pressed ? Buttons.B : 0); buttonsPressed |= (gpButtons.X == ButtonState.Pressed ? Buttons.X : 0); buttonsPressed |= (gpButtons.Y == ButtonState.Pressed ? Buttons.Y : 0); buttonsPressed |= (gpButtons.Start == ButtonState.Pressed ? Buttons.Start : 0); buttonsPressed |= (gpButtons.Back == ButtonState.Pressed ? Buttons.Back : 0); buttonsPressed |= gpState.IsButtonDown(Buttons.DPadDown) ? Buttons.DPadDown : 0; buttonsPressed |= gpState.IsButtonDown(Buttons.DPadLeft) ? Buttons.DPadLeft : 0; buttonsPressed |= gpState.IsButtonDown(Buttons.DPadRight) ? Buttons.DPadRight : 0; buttonsPressed |= gpState.IsButtonDown(Buttons.DPadUp) ? Buttons.DPadUp : 0; buttonsPressed |= (gpButtons.BigButton == ButtonState.Pressed ? Buttons.BigButton : 0); buttonsPressed |= (gpButtons.LeftShoulder == ButtonState.Pressed ? Buttons.LeftShoulder : 0); buttonsPressed |= (gpButtons.RightShoulder == ButtonState.Pressed ? Buttons.RightShoulder : 0); buttonsPressed |= (gpButtons.LeftStick == ButtonState.Pressed ? Buttons.LeftStick : 0); buttonsPressed |= (gpButtons.RightStick == ButtonState.Pressed ? Buttons.RightStick : 0); var buttons = new GamePadButtons(buttonsPressed); return new GamePadState(gpState.ThumbSticks, gpState.Triggers, buttons, gpState.DPad); }
protected override void Update(GameTime gameTime) { if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape)) Exit(); _keyState = Keyboard.GetState(); _padState = GamePad.GetState(PlayerIndex.One); //Let the Scene Manager do it's thing if ((_prevKeyState.IsKeyDown(Keys.P) && !_keyState.IsKeyDown(Keys.P)) || (_prevPadState.IsButtonDown(Buttons.Y) && !_padState.IsButtonDown(Buttons.Y))) { // The 'P' key has just been released // This will only fire ONCE when the 'P' key is released if (_pauseOn) _pauseOn = false; else _pauseOn = true; } if(!_pauseOn) _manager.NextScene().Update(gameTime); //Console.WriteLine(); _prevKeyState = _keyState; _prevPadState = _padState; base.Update(gameTime); }
/// <summary> /// Call this method when input is received to have the console react to the user's commands. /// </summary> /// <param name="kbs">The current keyboard state.</param> /// <returns>The Command that corresponds to the user's input.</returns> public void CheckInput(GamePadState gs) { if (_menuActive) { if (gs.IsButtonDown(Buttons.Y) && _oldPad.IsButtonUp(Buttons.Y)) _menuActive = false; } else { // Should we bring the menu up? if (gs.IsButtonDown(Buttons.Y) && _oldPad.IsButtonUp(Buttons.Y)) _menuActive = true; } _oldPad = gs; }
public override void Update( TimeSpan gameTime, KeyboardState keyState, MouseState mouseState, GamePadState padState ) { if ( keyState.IsKeyDown( Keys.Space ) || padState.IsButtonDown( Buttons.X ) || keyState.IsKeyDown( Keys.X ) ) { ReferMenu( null ); } }
private List<Command> handleController() { List<Command> commands = new List<Command>(); padState = GamePad.GetState(Microsoft.Xna.Framework.PlayerIndex.One); Vector2 move = new Vector2(); move.X = 0; move.Y = 0; if (padState.ThumbSticks.Left.Length() > .7f) { move.X = padState.ThumbSticks.Left.X * .7f; move.Y = -padState.ThumbSticks.Left.Y * .7f; } commands.Add(new MoveCommand(move)); Vector2 gazeDir = new Vector2(); gazeDir.X = padState.ThumbSticks.Right.X; gazeDir.Y = -padState.ThumbSticks.Right.Y; commands.Add(new GazeCommand(gazeDir)); if (padState.IsButtonDown(Buttons.RightShoulder)) commands.Add(new PunchCommand()); return commands; }
public void InputsPlayer(GameTime gameTime, bool move, bool jump, Player player) { // Save previous keyboard/gamepad states previousKeyboardState = currentKeyboardState; previousGamepadState = currentGamepadState; // Read current keyboard/gamepad currentKeyboardState = Keyboard.GetState(); currentGamepadState = GamePad.GetState(PlayerIndex.One); if (move && player.CanMove) { if (currentKeyboardState.IsKeyDown(Keys.Left) || currentGamepadState.ThumbSticks.Left.X < 0) player.Move(-1f); else if (currentKeyboardState.IsKeyDown(Keys.Right) || currentGamepadState.ThumbSticks.Left.X > 0) player.Move(1f); else player.Move(0f); } if (player.CanJump && jump) { if (currentGamepadState.IsButtonDown(Buttons.A) && previousGamepadState.IsButtonUp(Buttons.A)) player.Jump(); else if (currentKeyboardState.IsKeyDown(Keys.Z) && previousKeyboardState.IsKeyUp(Keys.Z)) player.Jump(); } if (player.IsOverDoor) { if (currentGamepadState.ThumbSticks.Left.Y < 0 && previousGamepadState.ThumbSticks.Left.Y < 0 && player.Velocity.X == 0 ) player.EnterDoor(); else if (currentKeyboardState.IsKeyDown(Keys.Up) && previousKeyboardState.IsKeyUp(Keys.Up) && player.Velocity.X == 0 ) player.EnterDoor(); } if (currentGamepadState.IsButtonDown(Buttons.B) && previousGamepadState.IsButtonUp(Buttons.B)) player.Attack(gameTime); else if (currentKeyboardState.IsKeyDown(Keys.X) && previousKeyboardState.IsKeyUp(Keys.X)) player.Attack(gameTime); }
public static void PickupGold(GamePadState gs, GamePadState previousGamePadState, Player player, GameTime gameTime) { var pickupGoldButton = actionKeys[Action.PickupGold]; if (gs.IsButtonDown(pickupGoldButton) && previousGamePadState.IsButtonUp(pickupGoldButton)) { player.AttemptPickupGold(); } }
public void Update() { motion = Vector2.Zero; keyboardState = Keyboard.GetState(); gamePadState = GamePad.GetState(PlayerIndex.One); if (keyboardState.IsKeyDown(Keys.Left) || gamePadState.IsButtonDown(Buttons.LeftThumbstickLeft)) motion.X = -1; if (keyboardState.IsKeyDown(Keys.Right) || gamePadState.IsButtonDown(Buttons.LeftThumbstickRight)) motion.X = 1; motion.X *= paddleSpeed; position += motion; checkInBounds(); }
public void Update(GamePadState pad) { if (pad.IsButtonDown(Buttons.A) && oldPad.IsButtonUp(Buttons.A)) { FirstGame.end = false; FirstGame.reload = true; } oldPad = pad; }
public void Update(GamePadState gs, GameTime gt) { prev = now; now = gs.IsButtonDown(btn); if(now) { pressed += gt.ElapsedGameTime; } else { pressed = new TimeSpan(0); } }
/// <summary> /// Static function that manages and updates everything that envolves the controller's buttons /// </summary> /// <param name="xboxState">The current state of the Xbox controller</param> /// <param name="mouseState">The current state of the mouse</param> public static void Process(GamePadState xboxState, MouseState mouseState) { //Check for exit if (xboxState.IsButtonDown(ApplicationData.exitProcess.Value)) Environment.Exit(0); //Update each button on the buttons list foreach (IXboxButton btn in ApplicationData.xboxButtons) btn.Update(xboxState, mouseState); }
public void GetPressedButtons(GamePadState gamePadState) { foreach (Buttons button in Enum.GetValues(typeof(Buttons))) { if (gamePadState.IsButtonDown(button)) { pressedButtons.Add(button); } } }
internal void Update(KeyboardState kbState, GamePadState gpState) { previousStatus = currentStatus; currentStatus = false; foreach (Keys k in keyList) if (kbState.IsKeyDown(k)) currentStatus = true; foreach (Buttons b in buttonList) if (gpState.IsButtonDown(b)) currentStatus = true; }
public static GamePadChangeSet getGamePadStateChange(GamePadState newState, GamePadState oldState) { GamePadChangeSet gamePadStateChanges; gamePadStateChanges.buttonChanges = new List<ButtonChange>(); foreach (Buttons but in Enum.GetValues(typeof(Buttons))) { if (newState.IsButtonDown(but) != oldState.IsButtonDown(but)) gamePadStateChanges.buttonChanges.Add( new ButtonChange() { button = but, state = newState.IsButtonDown(but) ? ButtonState.Pressed : ButtonState.Released } ); } return gamePadStateChanges; }
public void ConstructDPadState(Buttons button, ButtonState[] expectedDPadButtonStates) { var state = new GamePadState(Vector2.Zero, Vector2.Zero, 0f, 0f, button != 0 ? new Buttons[] { button } : new Buttons[] { }); if (button != 0) Assert.True(state.IsButtonDown(button)); Assert.AreEqual(expectedDPadButtonStates[0], state.DPad.Down, "DPad.Down Pressed or Released"); Assert.AreEqual(expectedDPadButtonStates[1], state.DPad.Left, "DPad.Left Pressed or Released"); Assert.AreEqual(expectedDPadButtonStates[2], state.DPad.Right, "DPad.Right Pressed or Released"); Assert.AreEqual(expectedDPadButtonStates[3], state.DPad.Up, "DPad.Up Pressed or Released"); }
/// <summary> /// Esta função reconhece a direção atual do controle a parti do estado do GamePad ou do teclado. /// Ela retorna um Button que pode ser comparado com as constantes dessa própria classe. /// </summary> /// <param name="gamePad">Estado do GamePad</param> /// <param name="keyboard">Estado do Teclado</param> /// <param name="keyboardMap">Mapa do teclado</param> /// <returns></returns> public static Buttons FromInput(GamePadState gamePad, KeyboardState keyboard, Dictionary<GameKeys, Keys> keyboardMap) { Buttons direction = None; //Pega a direção vertical. if (gamePad.IsButtonDown(Buttons.DPadUp) || gamePad.IsButtonDown(Buttons.LeftThumbstickUp) || keyboard.IsKeyDown(keyboardMap[GameKeys.Up])) { direction |= Up; } else if(gamePad.IsButtonDown(Buttons.DPadDown) || gamePad.IsButtonDown(Buttons.LeftThumbstickDown) || keyboard.IsKeyDown(keyboardMap[GameKeys.Down])) { direction |= Down; } //Combina com a direção horizontal. if (gamePad.IsButtonDown(Buttons.DPadLeft) || gamePad.IsButtonDown(Buttons.LeftThumbstickLeft) || keyboard.IsKeyDown(keyboardMap[GameKeys.Left])) { direction |= Left; } else if(gamePad.IsButtonDown(Buttons.DPadRight) || gamePad.IsButtonDown(Buttons.LeftThumbstickRight) || keyboard.IsKeyDown(keyboardMap[GameKeys.Right])) { direction |= Right; } return direction; }
public bool Accelerar() { if (_tecladoSelect) { keyboard = Keyboard.GetState(); return keyboard.IsKeyDown(Keys.W); } else { gamepad = GamePad.GetState(numplayer); return gamepad.IsButtonDown(Buttons.A); } }
public bool Abajo() { if (_tecladoSelect) { keyboard = Keyboard.GetState(); return keyboard.IsKeyDown(Keys.S); } else { gamepad = GamePad.GetState(numplayer); return gamepad.IsButtonDown(Buttons.LeftThumbstickDown); } }
// Update & Draw public void Update(MouseState mouse, KeyboardState keyboard, GamePadState gamePadState) { for (int i = 0; i < _btnNumber; i++) _buttons[i].Update(mouse, keyboard); if (keyboard.IsKeyDown(Keys.Down) || gamePadState.IsButtonDown(Buttons.DPadDown)) DownButton(); if (keyboard.IsKeyUp(Keys.Down) && gamePadState.IsButtonUp(Buttons.DPadDown)) _currentDownState = false; if (keyboard.IsKeyDown(Keys.Up) || gamePadState.IsButtonDown(Buttons.DPadUp)) UpButton(); if (keyboard.IsKeyUp(Keys.Up) && gamePadState.IsButtonUp(Buttons.DPadUp)) _currentUpState = false; if (keyboard.IsKeyDown(Keys.Enter) || gamePadState.Buttons.Start == ButtonState.Pressed || gamePadState.Buttons.A == ButtonState.Pressed) { switch (_selection) { case 0: { Game1.gameState = GameState.Game; break; } case 1: { break; } case 2: { exitGame = true; break; } } } }
/// <summary> /// Updates the button and executes it's wanted action if necessary /// </summary> /// <param name="xboxState">The current state of the Xbox Controller</param> /// <param name="mouseState">The current state of the mouse</param> public void Update(GamePadState xboxState, MouseState mouseState) { //Update the special buttons if (ApplicationData.control.HasValue && button == ApplicationData.control.Value) { control = xboxState.IsButtonDown(button); return; } if (ApplicationData.shift.HasValue && button == ApplicationData.shift.Value) { shift = xboxState.IsButtonDown(button); return; } if (ApplicationData.alt.HasValue && button == ApplicationData.alt.Value) { alt = xboxState.IsButtonDown(button); return; } if (xboxState.IsButtonDown(button)) { if (wasUp || (useTimer && timer.ElapsedMilliseconds > timerInterval)) { string addons = (control ? KeyboardButton.Control : "") + (shift ? KeyboardButton.Shift : "") + (alt ? KeyboardButton.Alt : ""); keyboard_event.SendWait(addons + keyboardButton); wasUp = false; if (useTimer) timer.Restart(); } } else wasUp = true; }
private void GetInput( KeyboardState keyboardState, GamePadState gamePadState) { //Getting analog horizontal movement hMovement = gamePadState.ThumbSticks.Left.X * MoveStickScale; //Ignoring small movements if (Math.Abs(hMovement) < 0.5f) hMovement = 0.0f; //Button presses if (gamePadState.IsButtonDown(Buttons.DPadDown) || keyboardState.IsKeyDown(Keys.Right)) { hMovement = -1.0f; } else if (gamePadState.IsButtonDown(Buttons.DPadDown) || keyboardState.IsKeyDown(Keys.Right)) { hMovement = 1.0f; } }
private Point MoveMousePointer(GameTime gameTime, GamePadState pad) { Vector2 change = new Vector2(0, 0); if (pad.IsButtonDown(Buttons.LeftThumbstickUp)) change.Y -= 1.0f; if (pad.IsButtonDown(Buttons.LeftThumbstickDown)) change.Y += 1.0f; if (pad.IsButtonDown(Buttons.LeftThumbstickLeft)) change.X -= 1.0f; if (pad.IsButtonDown(Buttons.LeftThumbstickRight)) change.X += 1.0f; change *= (float)(gameTime.ElapsedGameTime.TotalMilliseconds / 3); // Update the OS pointer POINT nativePointer; GetCursorPos(out nativePointer); nativePointer.x += (int)change.X; nativePointer.y += (int)change.Y; SetCursorPos(nativePointer.x, nativePointer.y); MouseState mouse = Mouse.GetState(); return new Point(mouse.X, mouse.Y); }
public void Update(GamePadState pad) { if ((pad.IsButtonDown(Buttons.LeftThumbstickDown) && !oldPad.IsButtonDown(Buttons.LeftThumbstickDown)) || (pad.IsButtonDown(Buttons.DPadDown)) && oldPad.IsButtonUp(Buttons.DPadDown)) { if (current < 3) { current++; } } if ((pad.IsButtonDown(Buttons.LeftThumbstickUp) && !oldPad.IsButtonDown(Buttons.LeftThumbstickUp)) || (pad.IsButtonDown(Buttons.DPadUp) && oldPad.IsButtonUp(Buttons.DPadUp))) { if (current > 1) { current--; } } if (pad.IsButtonDown(Buttons.A) && oldPad.IsButtonUp(Buttons.A)) { if (current == 1) { FirstGame.start = true; FirstGame.reloadCount = 0; FirstGame.checkpoint = false; } else if (current == 2) { FirstGame.credits = true; } else if (current == 3) { FirstGame.exit = true; } } oldPad = pad; }