public override void Update(Microsoft.Xna.Framework.GameTime gameTime) { _gamepad = XNAInput.GamePad.GetState((PlayerIndex)Index); base.Update(gameTime); MapButtonValue(_previousGamepad.Buttons.A, _gamepad.Buttons.A, MappingButtons.A); MapButtonValue(_previousGamepad.Buttons.B, _gamepad.Buttons.B, MappingButtons.B); MapButtonValue(_previousGamepad.Buttons.X, _gamepad.Buttons.X, MappingButtons.X); MapButtonValue(_previousGamepad.Buttons.Y, _gamepad.Buttons.Y, MappingButtons.Y); MapButtonValue(_previousGamepad.Buttons.Back, _gamepad.Buttons.Back, MappingButtons.Back); MapButtonValue(_previousGamepad.Buttons.Start, _gamepad.Buttons.Start, MappingButtons.Start); MapButtonValue(_previousGamepad.Buttons.BigButton, _gamepad.Buttons.BigButton, MappingButtons.Home); MapButtonValue(_previousGamepad.Buttons.LeftShoulder, _gamepad.Buttons.LeftShoulder, MappingButtons.LB); MapButtonValue(_previousGamepad.Buttons.RightShoulder, _gamepad.Buttons.RightShoulder, MappingButtons.RB); // Thumbsticks // ndDam: no stick "clic" for now ThumbStickLeft.X = _gamepad.ThumbSticks.Left.X; ThumbStickLeft.Y = _gamepad.ThumbSticks.Left.Y; ThumbStickRight.X = _gamepad.ThumbSticks.Right.X; ThumbStickRight.Y = _gamepad.ThumbSticks.Right.Y; _previousGamepad = _gamepad; }
private void UpdateDPadButtons(XnaInput.GamePadState state) { UpdateButton(state.DPad.Down, GamePadButton.Down); UpdateButton(state.DPad.Up, GamePadButton.Up); UpdateButton(state.DPad.Left, GamePadButton.Left); UpdateButton(state.DPad.Right, GamePadButton.Right); }
static Input() { oldGamePadStates = new GamePadState[MaxInputs]; newGamePadStates = new GamePadState[MaxInputs]; //oldKeyboardState = new KeyboardState[MaxInputs]; //newKeyboardState = new KeyboardState[MaxInputs]; }
private void UpdateStickAndShoulderButtons(XnaInput.GamePadState state) { UpdateButton(state.Buttons.LeftShoulder, GamePadButton.LeftShoulder); UpdateButton(state.Buttons.LeftStick, GamePadButton.LeftStick); UpdateButton(state.Buttons.RightShoulder, GamePadButton.RightShoulder); UpdateButton(state.Buttons.RightStick, GamePadButton.RightStick); }
/// <summary> /// Handles input, performs physics, and animates the player sprite. /// </summary> /// <remarks> /// We pass in all of the input states so that our game is only polling the hardware /// once per frame. We also pass the game's orientation because when using the accelerometer, /// we need to reverse our motion when the orientation is in the LandscapeRight orientation. /// </remarks> public void Update( GameTime gameTime, KeyboardState keyboardState, GamePadState gamePadState) { base.Update(gameTime); }
protected void AmbientToggle(KeyboardState currentKeyboardState, GamePadState currentGamePadState) { // toggle Ambient - Night/Day effect if (previousKeyboardState.IsKeyDown(Keys.E) && currentKeyboardState.IsKeyUp(Keys.E) || previousGamePadState.IsButtonDown(Buttons.RightShoulder) && currentGamePadState.IsButtonUp(Buttons.RightShoulder)) { ambient = !ambient; currentMusic.Stop(); currentMusic.Dispose(); // Ambient true sets to day time effect, false sets to night time effect if(ambient) { skyColor = Color.DeepSkyBlue; effect.Parameters["material"].StructureMembers["ambient"].SetValue(new Vector4(0.65f, 0.65f, 0.6f, 1.0f)); currentMusic = musicDay.CreateInstance(); } else { skyColor = Color.DarkSlateGray; effect.Parameters["material"].StructureMembers["ambient"].SetValue(new Vector4(0.1f, 0.1f, 0.15f, 1.0f)); currentMusic = musicNight.CreateInstance(); } enemy.Apply3DAudio(listener, enemy.Position, currentMusic); currentMusic.Play(); } }
/// <summary> /// Exit the screen after a tap or click /// </summary> /// <param name="input"></param> private void HandleInput(MouseState mouseState, GamePadState padState) { if (!isExit) { #if WINDOWS_PHONE if (ScreenManager.input.Gestures.Count > 0 && ScreenManager.input.Gestures[0].GestureType == GestureType.Tap) { isExit = true; } #else PlayerIndex result; if (mouseState.LeftButton == ButtonState.Pressed) { isExit = true; } else if (ScreenManager.input.IsNewButtonPress(Buttons.A, null, out result) || ScreenManager.input.IsNewButtonPress(Buttons.Start, null, out result)) { isExit = true; } #endif } }
public void Update(GameTime gameTime) { oldGs = gamePadState; gamePadState = GamePad.GetState(playerIndex, GamePadDeadZone.None); gamePadChanged = gamePadState != oldGs; }
/// <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; }
//******************************************** // Constructors //******************************************** public InputManager(Main game) { z_game = game; z_prevKeyState = z_curKeyState = new KeyboardState(); z_prevPadState = z_curPadState = new GamePadState(); SetDefaultControls(); }
/// <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() { // TODO: Add your initialization logic here base.Initialize(); previousGamePadState = GamePad.GetState(PlayerIndex.One); }
public float getAxis(GamePadState gamePadState, bool left, bool x) { if (x) { if (left) { return gamePadState.ThumbSticks.Left.X; } else { return gamePadState.ThumbSticks.Right.X; } } else { if (left) { return gamePadState.ThumbSticks.Left.Y; } else { return gamePadState.ThumbSticks.Right.Y; } } }
//Methods //Update & Draw public void Update(MouseState mouse, KeyboardState keyboard, GamePadState gamePadState) { if (keyboard.IsKeyUp(Keys.Escape) && gamePadState.Buttons.Start == ButtonState.Released) pauseAllowed = true; if ((keyboard.IsKeyDown(Keys.Escape) || gamePadState.Buttons.Start == ButtonState.Pressed) && pauseAllowed) { pauseAllowed = false; Game1.gameState = GameState.Pause; } if (mouse.X > 800) { Map.Current.position.X++; player.position.X++; } if (mouse.X < 200) { Map.Current.position.X--; player.position.X--; } Map.Current.Update(); player.Update(mouse, keyboard, gamePadState); }
public virtual void GamePadController(GamePadState state) { if (state.DPad.Down == ButtonState.Pressed && !(_previousGamePadState.DPad.Down == ButtonState.Pressed)) { _selectedIndex++; if (_selectedIndex == _levels.Length) _selectedIndex--; } else if (state.DPad.Up == ButtonState.Pressed && !(_previousGamePadState.DPad.Up == ButtonState.Pressed)) { _selectedIndex--; if (_selectedIndex < 0) _selectedIndex++; } else if (state.Buttons.A == ButtonState.Pressed &&!(_previousGamePadState.Buttons.A ==ButtonState.Pressed)) { var sample = _levels[_selectedIndex].CreateLevelFunction(); sample.OnLoad(); CurrentLevel = sample; } _previousGamePadState = state; }
public override void CaptureMouseState() { _gpState = XInput.GamePad.GetState( XFG.PlayerIndex.One ); relativeMousePosition.X = _gpState.ThumbSticks.Left.X; relativeMousePosition.Y = _gpState.ThumbSticks.Left.Y; }
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 override void Update(GameTime gameTime, GamePadState newGamePadState, GamePadState oldGamePadState, KeyboardState newKeyboardState, KeyboardState oldKeyboardState) { if ((newGamePadState.Buttons.A != oldGamePadState.Buttons.A && newGamePadState.Buttons.A == ButtonState.Pressed) || (newKeyboardState.IsKeyDown(Keys.Enter) && oldKeyboardState.IsKeyUp(Keys.Enter))) { Game.GameStartingScreen = GameStartingScreen.SetupScreen; } }
// 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 static List<InputManager.ACTIONS> GetInput() { currentGamePadState = GamePad.GetState(PlayerIndex.One); List<InputManager.ACTIONS> actions = new List<InputManager.ACTIONS>(); if (currentGamePadState.IsButtonUp(Buttons.A) && previousGamePadState.IsButtonDown(Buttons.A)) { actions.Add(InputManager.ACTIONS.JUMP); } if (currentGamePadState.ThumbSticks.Left.X > 0 || currentGamePadState.DPad.Right == ButtonState.Pressed) { actions.Add(InputManager.ACTIONS.RIGHT); } else if (currentGamePadState.ThumbSticks.Left.X < 0 || currentGamePadState.DPad.Left == ButtonState.Pressed) { actions.Add(InputManager.ACTIONS.LEFT); } if (currentGamePadState.IsButtonUp(Buttons.Y) && previousGamePadState.IsButtonDown(Buttons.Y)) { actions.Add(InputManager.ACTIONS.TOGGLE); } previousGamePadState = currentGamePadState; return actions; }
public void UpdateJump(KeyboardState aCurrentKeyboardState, GamePadState aCurrentGamePadState) { if ((CurrentState == State.Walking || CurrentState == State.Still) && (aCurrentKeyboardState.IsKeyDown(Keys.Up) == true || aCurrentGamePadState.DPad.Up == ButtonState.Pressed || aCurrentGamePadState.Buttons.A == ButtonState.Pressed)) { Jump(); } if (CurrentState == State.Jumping) { if (StartPosition.Y - Position.Y > 80) //At peak of jump... { Dir.Y = MOVE_DOWN; MoveSpeed.Y = 3.0f; } Position.Y = (Dir.Y == MOVE_DOWN) ? Position.Y + MoveSpeed.Y : Position.Y - MoveSpeed.Y; //Change Y position //END JUMP LOGIC if (Position.Y > StartPosition.Y) { Position.Y = StartPosition.Y; CurrentState = State.Still; Source = new Rectangle(0, 0, 28, Source.Height); Dir.Y = 0; MoveSpeed.X = 6.0f; MoveSpeed.Y = 3.5f; } } }
/// <summary> /// Updates key and pad states and also action values /// </summary> public void update() { keyState = Keyboard.GetState(); padState = GamePad.GetState(index); foreach (Action action in actionList) { if (keyState.IsKeyDown(action.key) || padState.IsButtonDown(action.button)) { action.isPressed = true; action.pressTime += 1; } else if ((keyState.IsKeyUp(action.key) && prevKeyState.IsKeyDown(action.key)) || (padState.IsButtonUp(action.button) && prevPadState.IsButtonDown(action.button))) { action.isPressed = false; action.pressTime = 0; }; } //Last run - store the current states //as the previous state prevKeyState = keyState; prevPadState = padState; }
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 void update(GamePadState gamePad, GameTime time) { if (! Menu.isActive()) { if (time.TotalGameTime.Milliseconds % 50 == 0) { if (gamePad.ThumbSticks.Left.X > 0 && position.X < maxPosition.X) position.X += cursorWidth; else if (gamePad.ThumbSticks.Left.X < 0 && position.X > 0) position.X -= cursorWidth; if (gamePad.ThumbSticks.Left.Y < 0 && position.Y < maxPosition.Y) position.Y += cursorHeight; else if (gamePad.ThumbSticks.Left.Y > 0 && position.Y > 0) position.Y -= cursorHeight; } if (time.TotalGameTime.Milliseconds % 200 == 0) { if (gamePad.DPad.Right == ButtonState.Pressed && position.X < maxPosition.X) position.X += cursorWidth; else if (gamePad.DPad.Left == ButtonState.Pressed && position.X > 0) position.X -= cursorWidth; if (gamePad.DPad.Down == ButtonState.Pressed && position.Y < maxPosition.Y) position.Y += cursorHeight; else if (gamePad.DPad.Up == ButtonState.Pressed && position.Y > 0) position.Y -= cursorHeight; } } }
public override void Update(GameTime gameTime, EventManager events) { base.Update(gameTime, events); #region GamePad // GamePad P1LastGamePadState = P1GamePadState; P1GamePadState = GamePad.GetState(PlayerIndex.One); bool left = P1GamePadState.ThumbSticks.Left.X < 0.0f; bool right = P1GamePadState.ThumbSticks.Left.X > 0.0f; bool jump = (P1GamePadState.Buttons.A == ButtonState.Pressed && P1LastGamePadState.Buttons.A == ButtonState.Released); bool action = (P1GamePadState.Buttons.B == ButtonState.Released && P1LastGamePadState.Buttons.B == ButtonState.Pressed); #endregion #region Keyboard bool keyJump = (keyboard.IsKeyDown(Keys.Up) && lastKeyboard.IsKeyUp(Keys.Up)); bool keyDownLeft = keyboard.IsKeyDown(Keys.Left); bool keyDownRight = keyboard.IsKeyDown(Keys.Right); bool keyAction = keyboard.IsKeyUp(Keys.Space) && lastKeyboard.IsKeyDown(Keys.Space); #endregion if (action || keyAction) events.Notify(Event.Action, null); }
// // Horizontal Movement protected void CheckHorizontalMovementKeys(KeyboardState ksKeys, GamePadState gsPad) { bool bResetTimer = false; player.Thrusting = false; if ((ksKeys.IsKeyDown(Keys.Right)) || (gsPad.ThumbSticks.Left.X > 0)) { if (player.ScrollRate < iMaxHorizontalSpeed) { player.ScrollRate += player.AccelerationRate; if (player.ScrollRate > iMaxHorizontalSpeed) player.ScrollRate = iMaxHorizontalSpeed; bResetTimer = true; } player.Thrusting = true; player.Facing = 0; } if ((ksKeys.IsKeyDown(Keys.Left)) || (gsPad.ThumbSticks.Left.X < 0)) { if (player.ScrollRate > -iMaxHorizontalSpeed) { player.ScrollRate -= player.AccelerationRate; if (player.ScrollRate < -iMaxHorizontalSpeed) player.ScrollRate = -iMaxHorizontalSpeed; bResetTimer = true; } player.Thrusting = true; player.Facing = 1; } if (bResetTimer) player.SpeedChangeCount = 0.0f; }
public override void Update(float deltaTime) { if (id == World.gameId) { gamePad = GamePad.GetState(PlayerIndex.One); keyboard = Keyboard.GetState(); if (gamePad.Buttons.Y == ButtonState.Pressed && oldGamePad.Buttons.Y == ButtonState.Released && World.inMenu == false || keyboard.IsKeyDown(Keys.Tab) && oldKeyboard.IsKeyUp(Keys.Tab) && World.inMenu == false) { World.inMenu = true; World.menuManager.SwitchMenu(World.menuManager.shop); } else if (keyboard.IsKeyDown(Keys.Tab) && oldKeyboard.IsKeyUp(Keys.Tab) && World.inMenu == true) { World.menuManager.CurrentMenu.BackOut(); } } oldGamePad = gamePad; oldKeyboard = keyboard; base.Update(deltaTime); }
//========================================================================================= /// <summary> /// Constructor. Creates the object. /// </summary> //========================================================================================= public Gui_Game_Paused() { // Save the current kb and gamepad state; m_last_gamepad_state = GamePad.GetState(PlayerIndex.One); m_last_keyboard_state = Keyboard.GetState(); }
/// <summary> /// Performs the logic to control the Player. /// </summary> /// <param name="pad">The state of the gamepad used to control this player.</param> public void Update(GamePadState pad) { if (pad.ThumbSticks.Left.X >= 0.5) pos.X += speed; if (pad.ThumbSticks.Left.X <= -0.5) pos.X -= speed; if (pad.ThumbSticks.Left.Y >= 0.5) pos.Y -= speed; if (pad.ThumbSticks.Left.Y <= -0.5) pos.Y += speed; }
public void Update() { kbo = kb; gpo = gp; kb = Keyboard.GetState(); this.gp = GamePad.GetState(PlayerIndex.One); }
public GetInput(PlayerIndex index) { playerIndex = index; directionBoolArray = new bool[4] { upPressed, leftPressed, downPressed, rightPressed }; oldKeyState = Keyboard.GetState(); oldPadState = GamePad.GetState(playerIndex); }
public Controls() { this.kb = Keyboard.GetState(); this.kbo = Keyboard.GetState(); this.gp = GamePad.GetState(PlayerIndex.One); this.gpo = GamePad.GetState(PlayerIndex.One); }
public void Update(Vector2 pos, MouseState mouse, GamePadState gps, GameTime gameTime) { //check user Drag Drop Events if (mouse.LeftButton == ButtonState.Pressed || gps.Buttons.A == ButtonState.Pressed) { //CHECK BUTTONS int clickedID = getClickedID(new Vector2(pos.X, pos.Y)); if (clickedID >= 0) { if (clickedID == 1) { main.stateManager.loadNextScreen(2, 0, gameTime); } if (clickedID == 2) { main.stateManager.loadNextScreen(4, 0, gameTime); } if (clickedID == 3) { main.lastState = 1; main.stateManager.loadNextScreen(5, 0, gameTime); } Console.WriteLine("BUTTON PRESSED: clickedID: "+clickedID); //APACURRO BOTONES } } }
/// <summary> /// Constructs a new input state. /// </summary> public InputHelper(ScreenManager manager) { _currentKeyboardState = new KeyboardState(); _currentGamePadState = new GamePadState(); _currentMouseState = new MouseState(); _currentVirtualState = new GamePadState(); _lastKeyboardState = new KeyboardState(); _lastGamePadState = new GamePadState(); _lastMouseState = new MouseState(); _lastVirtualState = new GamePadState(); _manager = manager; _cursorIsVisible = false; _cursorMoved = false; #if WINDOWS_PHONE _cursorIsValid = false; #else _cursorIsValid = true; #endif _cursor = Vector2.Zero; _handleVirtualStick = true; }
private void UpdateNormalButtons(XnaInput.GamePadState state) { UpdateButton(state.Buttons.A, GamePadButton.A); UpdateButton(state.Buttons.B, GamePadButton.B); UpdateButton(state.Buttons.X, GamePadButton.X); UpdateButton(state.Buttons.Y, GamePadButton.Y); UpdateButton(state.Buttons.Back, GamePadButton.Back); UpdateButton(state.Buttons.Start, GamePadButton.Start); UpdateButton(state.Buttons.BigButton, GamePadButton.BigButton); }
internal bool Update(xinput.GamePadState curr) { if (_isConnected == curr.IsConnected) { return(false); } _isConnected = curr.IsConnected; return(true); }
internal bool Update(DateTime timeStamp, xinput.GamePadState state) { if (_previous == state) { return(false); } _timeStamp = timeStamp; _previous = state; return(true); }
public override void Update(GameTime gameTime) { lastState = st; st = XnaInput.GamePad.GetState(index); if (cooldown > 0) { if (triggered) { try { if (!vibrationFaild) { Controller.SetVibration(vibration); } } catch (Exception) { vibrationFaild = true; } triggered = false; vibrating = true; } cooldown -= gameTime.ElapsedGameTime.TotalMilliseconds; if (cooldown <= 0) { vibration.LeftMotorSpeed = 0; vibration.RightMotorSpeed = 0; try { if (!vibrationFaild) { Controller.SetVibration(vibration); } vibrating = false; } catch (Exception) { vibrationFaild = true; } } } }
public virtual IEnumerator <ITask> PollHandler(Poll poll) { DateTime timeStamp = DateTime.Now; xinput.GamePadState gamepad = _state.GetState(); if (_state.Update(timeStamp, gamepad)) { if (_state.Controller.Update(gamepad)) { SendNotification <ControllerChanged>(_submgr, _state.Controller); } if (_state.DPad.Update(timeStamp, gamepad.DPad)) { SendNotification <DPadChanged>(_submgr, _state.DPad); } if (_state.Buttons.Update(timeStamp, gamepad.Buttons)) { SendNotification <ButtonsChanged>(_submgr, _state.Buttons); } if (_state.Triggers.Update(timeStamp, gamepad.Triggers)) { SendNotification <TriggersChanged>(_submgr, _state.Triggers); } if (_state.Thumbsticks.Update(timeStamp, gamepad.ThumbSticks)) { SendNotification <ThumbsticksChanged>(_submgr, _state.Thumbsticks); } } poll.ResponsePort.Post(DefaultSubmitResponseType.Instance); yield break; }
private bool GetInternal(XnaInput.GamePadState st, Buttons btn) { switch (btn) { case Buttons.A: return(st.Buttons.A == XnaInput.ButtonState.Pressed); case Buttons.B: return(st.Buttons.B == XnaInput.ButtonState.Pressed); case Buttons.X: return(st.Buttons.X == XnaInput.ButtonState.Pressed); case Buttons.Y: return(st.Buttons.Y == XnaInput.ButtonState.Pressed); case Buttons.R: return(st.Buttons.RightShoulder == XnaInput.ButtonState.Pressed); case Buttons.L: return(st.Buttons.LeftShoulder == XnaInput.ButtonState.Pressed); case Buttons.LeftStick: return(st.Buttons.LeftStick == XnaInput.ButtonState.Pressed); case Buttons.RightStick: return(st.Buttons.RightStick == XnaInput.ButtonState.Pressed); case Buttons.DPad_Left: return(st.DPad.Left == XnaInput.ButtonState.Pressed); case Buttons.DPad_Right: return(st.DPad.Right == XnaInput.ButtonState.Pressed); case Buttons.DPad_Up: return(st.DPad.Up == XnaInput.ButtonState.Pressed); case Buttons.DPad_Down: return(st.DPad.Down == XnaInput.ButtonState.Pressed); case Buttons.Select: return(st.Buttons.Back == XnaInput.ButtonState.Pressed); case Buttons.Start: return(st.Buttons.Start == XnaInput.ButtonState.Pressed); case Buttons.ToggleFullscreen: return(st.Buttons.Back == XnaInput.ButtonState.Pressed); } return(false); }
private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode) { // If the device was disconneced then wait for // the timeout to elapsed before we test it again. if (!_connected[index] && !HasDisconnectedTimeoutElapsed(index)) { return(GetDefaultState()); } int packetNumber = 0; // Try to get the controller state. var gamepad = new SharpDX.XInput.Gamepad(); try { SharpDX.XInput.State xistate; var controller = _controllers[index]; _connected[index] = controller.GetState(out xistate); packetNumber = xistate.PacketNumber; gamepad = xistate.Gamepad; } catch (Exception) { } // If the device is disconnected retry it after the // timeout period has elapsed to avoid the overhead. if (!_connected[index]) { SetDisconnectedTimeout(index); return(GetDefaultState()); } var thumbSticks = new GamePadThumbSticks( leftPosition: new Vector2(gamepad.LeftThumbX, gamepad.LeftThumbY) / (float)short.MaxValue, rightPosition: new Vector2(gamepad.RightThumbX, gamepad.RightThumbY) / (float)short.MaxValue, leftDeadZoneMode: leftDeadZoneMode, rightDeadZoneMode: rightDeadZoneMode); var triggers = new GamePadTriggers( leftTrigger: gamepad.LeftTrigger / (float)byte.MaxValue, rightTrigger: gamepad.RightTrigger / (float)byte.MaxValue); var dpadState = new GamePadDPad( upValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadUp), downValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadDown), leftValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadLeft), rightValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadRight)); var buttons = ConvertToButtons( buttonFlags: gamepad.Buttons, leftTrigger: gamepad.LeftTrigger, rightTrigger: gamepad.RightTrigger); var state = new GamePadState( thumbSticks: thumbSticks, triggers: triggers, buttons: buttons, dPad: dpadState); state.PacketNumber = packetNumber; return(state); }
private static GamePadState PlatformGetState(int index, GamePadDeadZone deadZoneMode) { var ind = (GCControllerPlayerIndex)index; var buttons = new List <Buttons>(); bool connected = false; ButtonState Up = ButtonState.Released; ButtonState Down = ButtonState.Released; ButtonState Left = ButtonState.Released; ButtonState Right = ButtonState.Released; Vector2 leftThumbStickPosition = Vector2.Zero; Vector2 rightThumbStickPosition = Vector2.Zero; float leftTriggerValue = 0; float rightTriggerValue = 0; AssingIndex(ind); foreach (var controller in GCController.Controllers) { if (controller == null) { continue; } if (controller.PlayerIndex != (int)ind) { continue; } connected = true; if (controller.ExtendedGamepad != null) { if (controller.ExtendedGamepad.ButtonA.IsPressed == true && !buttons.Contains(Buttons.A)) { buttons.Add(Buttons.A); } if (controller.ExtendedGamepad.ButtonB.IsPressed == true && !buttons.Contains(Buttons.B)) { buttons.Add(Buttons.B); } if (controller.ExtendedGamepad.ButtonX.IsPressed == true && !buttons.Contains(Buttons.X)) { buttons.Add(Buttons.X); } if (controller.ExtendedGamepad.ButtonY.IsPressed == true && !buttons.Contains(Buttons.Y)) { buttons.Add(Buttons.Y); } if (controller.ExtendedGamepad.LeftShoulder.IsPressed == true && !buttons.Contains(Buttons.LeftShoulder)) { buttons.Add(Buttons.LeftShoulder); } if (controller.ExtendedGamepad.RightShoulder.IsPressed == true && !buttons.Contains(Buttons.RightShoulder)) { buttons.Add(Buttons.RightShoulder); } Up = controller.ExtendedGamepad.DPad.Up.IsPressed ? ButtonState.Pressed : ButtonState.Released; Down = controller.ExtendedGamepad.DPad.Down.IsPressed ? ButtonState.Pressed : ButtonState.Released; Left = controller.ExtendedGamepad.DPad.Left.IsPressed ? ButtonState.Pressed : ButtonState.Released; Right = controller.ExtendedGamepad.DPad.Right.IsPressed ? ButtonState.Pressed : ButtonState.Released; leftThumbStickPosition.X = controller.ExtendedGamepad.LeftThumbstick.XAxis.Value; leftThumbStickPosition.Y = controller.ExtendedGamepad.LeftThumbstick.YAxis.Value; rightThumbStickPosition.X = controller.ExtendedGamepad.RightThumbstick.XAxis.Value; rightThumbStickPosition.Y = controller.ExtendedGamepad.RightThumbstick.YAxis.Value; leftTriggerValue = controller.ExtendedGamepad.LeftTrigger.Value; rightTriggerValue = controller.ExtendedGamepad.RightTrigger.Value; } else if (controller.Gamepad != null) { if (controller.Gamepad.ButtonA.IsPressed == true && !buttons.Contains(Buttons.A)) { buttons.Add(Buttons.A); } if (controller.Gamepad.ButtonB.IsPressed == true && !buttons.Contains(Buttons.B)) { buttons.Add(Buttons.B); } if (controller.Gamepad.ButtonX.IsPressed == true && !buttons.Contains(Buttons.X)) { buttons.Add(Buttons.X); } if (controller.Gamepad.ButtonY.IsPressed == true && !buttons.Contains(Buttons.Y)) { buttons.Add(Buttons.Y); } Up = controller.Gamepad.DPad.Up.IsPressed ? ButtonState.Pressed : ButtonState.Released; Down = controller.Gamepad.DPad.Down.IsPressed ? ButtonState.Pressed : ButtonState.Released; Left = controller.Gamepad.DPad.Left.IsPressed ? ButtonState.Pressed : ButtonState.Released; Right = controller.Gamepad.DPad.Right.IsPressed ? ButtonState.Pressed : ButtonState.Released; } } var state = new GamePadState( new GamePadThumbSticks(leftThumbStickPosition, rightThumbStickPosition), new GamePadTriggers(leftTriggerValue, rightTriggerValue), new GamePadButtons(buttons.ToArray()), new GamePadDPad(Up, Down, Left, Right)); state.IsConnected = connected; return(state); }
private void UpdateAllButtons(XnaInput.GamePadState state) { UpdateNormalButtons(state); UpdateStickAndShoulderButtons(state); UpdateDPadButtons(state); }
public static GamePadState GetState(PlayerIndex playerIndex, GamePadDeadZone deadZoneMode) { IntPtr device = INTERNAL_devices[(int)playerIndex]; if (device == IntPtr.Zero) { return(InitializedState); } // Do not attempt to understand this number at all costs! const float DeadZoneSize = 0.27f; // SDL_GameController if (INTERNAL_isGameController[(int)playerIndex]) { // The "master" button state is built from this. Buttons gc_buttonState = (Buttons)0; // Sticks GamePadThumbSticks gc_sticks = new GamePadThumbSticks( new Vector2( (float)SDL.SDL_GameControllerGetAxis( device, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTX ) / 32768.0f, (float)SDL.SDL_GameControllerGetAxis( device, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTY ) / -32768.0f ), new Vector2( (float)SDL.SDL_GameControllerGetAxis( device, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_RIGHTX ) / 32768.0f, (float)SDL.SDL_GameControllerGetAxis( device, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_RIGHTY ) / -32768.0f ) ); gc_sticks.ApplyDeadZone(deadZoneMode, DeadZoneSize); gc_buttonState |= READ_StickToButtons( gc_sticks.Left, Buttons.LeftThumbstickLeft, Buttons.LeftThumbstickRight, Buttons.LeftThumbstickUp, Buttons.LeftThumbstickDown, DeadZoneSize ); gc_buttonState |= READ_StickToButtons( gc_sticks.Right, Buttons.RightThumbstickLeft, Buttons.RightThumbstickRight, Buttons.RightThumbstickUp, Buttons.RightThumbstickDown, DeadZoneSize ); // Triggers GamePadTriggers gc_triggers = new GamePadTriggers( (float)SDL.SDL_GameControllerGetAxis( device, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_TRIGGERLEFT ) / 32768.0f, (float)SDL.SDL_GameControllerGetAxis( device, SDL.SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_TRIGGERRIGHT ) / 32768.0f ); gc_buttonState |= READ_TriggerToButton( gc_triggers.Left, Buttons.LeftTrigger, DeadZoneSize ); gc_buttonState |= READ_TriggerToButton( gc_triggers.Right, Buttons.RightTrigger, DeadZoneSize ); // Buttons if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A) != 0) { gc_buttonState |= Buttons.A; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B) != 0) { gc_buttonState |= Buttons.B; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X) != 0) { gc_buttonState |= Buttons.X; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y) != 0) { gc_buttonState |= Buttons.Y; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_BACK) != 0) { gc_buttonState |= Buttons.Back; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_GUIDE) != 0) { gc_buttonState |= Buttons.BigButton; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START) != 0) { gc_buttonState |= Buttons.Start; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK) != 0) { gc_buttonState |= Buttons.LeftStick; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSTICK) != 0) { gc_buttonState |= Buttons.RightStick; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER) != 0) { gc_buttonState |= Buttons.LeftShoulder; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER) != 0) { gc_buttonState |= Buttons.RightShoulder; } // DPad GamePadDPad gc_dpad; if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_UP) != 0) { gc_buttonState |= Buttons.DPadUp; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_DOWN) != 0) { gc_buttonState |= Buttons.DPadDown; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_LEFT) != 0) { gc_buttonState |= Buttons.DPadLeft; } if (SDL.SDL_GameControllerGetButton(device, SDL.SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_DPAD_RIGHT) != 0) { gc_buttonState |= Buttons.DPadRight; } gc_dpad = new GamePadDPad(gc_buttonState); // Compile the master buttonstate GamePadButtons gc_buttons = new GamePadButtons(gc_buttonState); // Build the GamePadState, increment PacketNumber if state changed. GamePadState gc_builtState = new GamePadState( gc_sticks, gc_triggers, gc_buttons, gc_dpad ); gc_builtState.PacketNumber = INTERNAL_states[(int)playerIndex].PacketNumber; if (gc_builtState != INTERNAL_states[(int)playerIndex]) { gc_builtState.PacketNumber += 1; INTERNAL_states[(int)playerIndex] = gc_builtState; } return(gc_builtState); } // SDL_Joystick // We will interpret the joystick values into this. Buttons buttonState = (Buttons)0; // Sticks GamePadThumbSticks sticks = new GamePadThumbSticks( new Vector2( READTYPE_ReadFloat(INTERNAL_joystickConfig.AXIS_LX, device), -READTYPE_ReadFloat(INTERNAL_joystickConfig.AXIS_LY, device) ), new Vector2( READTYPE_ReadFloat(INTERNAL_joystickConfig.AXIS_RX, device), -READTYPE_ReadFloat(INTERNAL_joystickConfig.AXIS_RY, device) ) ); sticks.ApplyDeadZone(deadZoneMode, DeadZoneSize); buttonState |= READ_StickToButtons( sticks.Left, Buttons.LeftThumbstickLeft, Buttons.LeftThumbstickRight, Buttons.LeftThumbstickUp, Buttons.LeftThumbstickDown, DeadZoneSize ); buttonState |= READ_StickToButtons( sticks.Right, Buttons.RightThumbstickLeft, Buttons.RightThumbstickRight, Buttons.RightThumbstickUp, Buttons.RightThumbstickDown, DeadZoneSize ); // Buttons buttonState = READ_ReadButtons(device, DeadZoneSize); // Triggers GamePadTriggers triggers = new GamePadTriggers( READTYPE_ReadFloat(INTERNAL_joystickConfig.TRIGGER_LT, device), READTYPE_ReadFloat(INTERNAL_joystickConfig.TRIGGER_RT, device) ); buttonState |= READ_TriggerToButton( triggers.Left, Buttons.LeftTrigger, DeadZoneSize ); buttonState |= READ_TriggerToButton( triggers.Right, Buttons.RightTrigger, DeadZoneSize ); // Compile the GamePadButtons with our Buttons state GamePadButtons buttons = new GamePadButtons(buttonState); // DPad GamePadDPad dpad = new GamePadDPad(buttons.buttons); // Build the GamePadState, increment PacketNumber if state changed. GamePadState builtState = new GamePadState( sticks, triggers, buttons, dpad ); builtState.PacketNumber = INTERNAL_states[(int)playerIndex].PacketNumber; if (builtState != INTERNAL_states[(int)playerIndex]) { builtState.PacketNumber += 1; INTERNAL_states[(int)playerIndex] = builtState; } return(builtState); }
private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode) { var ind = (GCControllerPlayerIndex)index; Buttons buttons = 0; bool connected = false; ButtonState Up = ButtonState.Released; ButtonState Down = ButtonState.Released; ButtonState Left = ButtonState.Released; ButtonState Right = ButtonState.Released; Vector2 leftThumbStickPosition = Vector2.Zero; Vector2 rightThumbStickPosition = Vector2.Zero; float leftTriggerValue = 0; float rightTriggerValue = 0; AssingIndex(ind); foreach (var controller in GCController.Controllers) { if (controller == null) { continue; } if (controller.PlayerIndex != (int)ind) { continue; } connected = true; if (controller.ExtendedGamepad != null) { if (controller.ExtendedGamepad.ButtonA.IsPressed) { buttons |= Buttons.A; } if (controller.ExtendedGamepad.ButtonB.IsPressed) { buttons |= Buttons.B; } if (controller.ExtendedGamepad.ButtonX.IsPressed) { buttons |= Buttons.X; } if (controller.ExtendedGamepad.ButtonY.IsPressed) { buttons |= Buttons.Y; } if (controller.ExtendedGamepad.LeftShoulder.IsPressed) { buttons |= Buttons.LeftShoulder; } if (controller.ExtendedGamepad.RightShoulder.IsPressed) { buttons |= Buttons.RightShoulder; } if (controller.ExtendedGamepad.LeftTrigger.IsPressed) { buttons |= Buttons.LeftTrigger; } if (controller.ExtendedGamepad.RightTrigger.IsPressed) { buttons |= Buttons.RightTrigger; } if (controller.ExtendedGamepad.DPad.Up.IsPressed) { Up = ButtonState.Pressed; buttons |= Buttons.DPadUp; } if (controller.ExtendedGamepad.DPad.Down.IsPressed) { Down = ButtonState.Pressed; buttons |= Buttons.DPadDown; } if (controller.ExtendedGamepad.DPad.Left.IsPressed) { Left = ButtonState.Pressed; buttons |= Buttons.DPadLeft; } if (controller.ExtendedGamepad.DPad.Right.IsPressed) { Right = ButtonState.Pressed; buttons |= Buttons.DPadRight; } leftThumbStickPosition.X = controller.ExtendedGamepad.LeftThumbstick.XAxis.Value; leftThumbStickPosition.Y = controller.ExtendedGamepad.LeftThumbstick.YAxis.Value; rightThumbStickPosition.X = controller.ExtendedGamepad.RightThumbstick.XAxis.Value; rightThumbStickPosition.Y = controller.ExtendedGamepad.RightThumbstick.YAxis.Value; leftTriggerValue = controller.ExtendedGamepad.LeftTrigger.Value; rightTriggerValue = controller.ExtendedGamepad.RightTrigger.Value; } else if (controller.Gamepad != null) { if (controller.Gamepad.ButtonA.IsPressed) { buttons |= Buttons.A; } if (controller.Gamepad.ButtonB.IsPressed) { buttons |= Buttons.B; } if (controller.Gamepad.ButtonX.IsPressed) { buttons |= Buttons.X; } if (controller.Gamepad.ButtonY.IsPressed) { buttons |= Buttons.Y; } if (controller.Gamepad.DPad.Up.IsPressed) { Up = ButtonState.Pressed; buttons |= Buttons.DPadUp; } if (controller.Gamepad.DPad.Down.IsPressed) { Down = ButtonState.Pressed; buttons |= Buttons.DPadDown; } if (controller.Gamepad.DPad.Left.IsPressed) { Left = ButtonState.Pressed; buttons |= Buttons.DPadLeft; } if (controller.Gamepad.DPad.Right.IsPressed) { Right = ButtonState.Pressed; buttons |= Buttons.DPadRight; } } } var state = new GamePadState( new GamePadThumbSticks(leftThumbStickPosition, rightThumbStickPosition, leftDeadZoneMode, rightDeadZoneMode), new GamePadTriggers(leftTriggerValue, rightTriggerValue), new GamePadButtons(buttons), new GamePadDPad(Up, Down, Left, Right)); state.IsConnected = connected; return(state); }