• XNA游戏:各种输入测试


    测试XNA游戏中键盘输入,触控输入,按钮输入

    Game1.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.GamerServices;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Input.Touch;
    using Microsoft.Xna.Framework.Media;
    
    using InputHandlerDemo.Inputs;
    
    namespace InputHandlerDemo
    {
        public class Game1 : Microsoft.Xna.Framework.Game
        {
            GraphicsDeviceManager graphics;
            SpriteBatch spriteBatch;
    
            SpriteFont font;
            Texture2D square;
            string action = "";
    
            GameInput gameInput;//游戏输入管理类
            TouchIndicatorCollection touchIndicators;
    
            Rectangle JumpRectangle = new Rectangle(0, 0, 480, 100);
            Rectangle UpRectangle = new Rectangle(0, 150, 480, 100);
            Rectangle PauseRectangle = new Rectangle(0, 500, 200, 100);
            //退出矩形
            Rectangle ExitRectangle = new Rectangle(220, 500, 200, 100);
    
    
            public Game1()
            {
                graphics = new GraphicsDeviceManager(this);
                Content.RootDirectory = "Content";
                TargetElapsedTime = TimeSpan.FromTicks(333333);
                //设置高度和宽度
                graphics.PreferredBackBufferWidth = 480;
                graphics.PreferredBackBufferHeight = 800;  
    
            }
    
            protected override void Initialize()
            {
                //初始化游戏输入对象
                gameInput = new GameInput();
                touchIndicators = new TouchIndicatorCollection();
    
                AddInputs();
    
                base.Initialize();
            }
            /// <summary>
            /// 添加各种输入方式
            /// </summary>
            private void AddInputs()
            {
                //游戏按钮
    
                // Add keyboard, gamepad and touch inputs for Jump
                gameInput.AddKeyboardInput(Actions.Jump, Keys.A, true);//A键为跳
                gameInput.AddKeyboardInput(Actions.Jump, Keys.Space, false);//Space键为跳
                gameInput.AddTouchTapInput(Actions.Jump, JumpRectangle, false);//跳矩形区域为跳
                gameInput.AddTouchSlideInput(Actions.Jump, Input.Direction.Right, 5.0f);//右滑动为跳
    
                // Add keyboard, gamepad and touch inputs for Pause
                gameInput.AddGamePadInput(Actions.Pause, Buttons.Start, true);
                gameInput.AddKeyboardInput(Actions.Pause, Keys.P, true);
                gameInput.AddTouchTapInput(Actions.Pause, PauseRectangle, true);
                gameInput.AddAccelerometerInput(Actions.Pause,
                                                Input.Direction.Down,
                                                0.10f);
    
                // Add keyboard, gamepad and touch inputs for Up
                gameInput.AddGamePadInput(Actions.Up, Buttons.RightThumbstickUp, false);
                gameInput.AddGamePadInput(Actions.Up, Buttons.LeftThumbstickUp, false);
                gameInput.AddGamePadInput(Actions.Up, Buttons.DPadUp, false);
                gameInput.AddKeyboardInput(Actions.Up, Keys.Up, false);
                gameInput.AddKeyboardInput(Actions.Up, Keys.W, true);
                gameInput.AddTouchTapInput(Actions.Up, UpRectangle, true);
                gameInput.AddTouchSlideInput(Actions.Up, Input.Direction.Up, 5.0f);
                gameInput.AddAccelerometerInput(Actions.Up,
                                                Input.Direction.Up,
                                                0.10f);
    
                // Add keyboard, gamepad and touch inputs for Exit
                gameInput.AddGamePadInput(Actions.Exit, Buttons.Back, false);
                gameInput.AddKeyboardInput(Actions.Exit, Keys.Escape, false);
                gameInput.AddTouchTapInput(Actions.Exit, ExitRectangle, true);
    
                // Add some Gestures too, just to show them off?
                gameInput.AddTouchGestureInput(Actions.Jump,
                                               GestureType.VerticalDrag,
                                               JumpRectangle);
                gameInput.AddTouchGestureInput(Actions.Pause,
                                               GestureType.Hold,
                                               PauseRectangle);
            }
    
            protected override void LoadContent()
            {
                // Create a new SpriteBatch, which can be used to draw textures.
                spriteBatch = new SpriteBatch(GraphicsDevice);
    
                //加载内容
                font = Content.Load<SpriteFont>("Display");
                square = Content.Load<Texture2D>("Pixel");
    
            }
    
            protected override void UnloadContent()
            {
            }
    
            protected override void Update(GameTime gameTime)
            {
                if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                    this.Exit();
    
                //根据输入类型更新游戏界面
                gameInput.BeginUpdate();
    
                //点击退出矩形,退出程序
                if (gameInput.IsPressed(Actions.Exit, PlayerIndex.One))
                    this.Exit();
    
                if (gameInput.IsPressed(Actions.Jump, PlayerIndex.One))
                    action = Actions.Jump;
      
                if (gameInput.IsPressed(Actions.Pause, PlayerIndex.One))
                    action = Actions.Pause;
    
                if (gameInput.IsPressed(Actions.Up, PlayerIndex.One))
                    action = Actions.Up;
    
                touchIndicators.Update(gameTime, Content);
    
                gameInput.EndUpdate();
    
                base.Update(gameTime);
            }
    
            protected override void Draw(GameTime gameTime)
            {
                GraphicsDevice.Clear(Color.CornflowerBlue);
    
                //绘制游戏界面
                spriteBatch.Begin();
    
                spriteBatch.Draw(square, UpRectangle, Color.Blue);
                spriteBatch.DrawString(font,
                                       "Up",
                                       new Vector2(UpRectangle.Left + 20, UpRectangle.Top + 20),
                                       Color.Black);
    
                spriteBatch.Draw(square, JumpRectangle, Color.Yellow);
                spriteBatch.DrawString(font,
                                       "Jump",
                                       new Vector2(JumpRectangle.Left + 20, JumpRectangle.Top + 20),
                                       Color.Black);
    
                spriteBatch.Draw(square, PauseRectangle, Color.Green);
                spriteBatch.DrawString(font,
                                       "Pause",
                                       new Vector2(PauseRectangle.Left + 20, PauseRectangle.Top + 20),
                                       Color.Black);
    
                spriteBatch.Draw(square, ExitRectangle, Color.Red);
                spriteBatch.DrawString(font,
                                       "Exit",
                                       new Vector2(ExitRectangle.Left + 20, ExitRectangle.Top + 20),
                                       Color.Black);
    
                spriteBatch.DrawString(font, action, new Vector2(100, 350), Color.White);
    
                touchIndicators.Draw(spriteBatch);
    
                spriteBatch.End(); 
    
                base.Draw(gameTime);
            }
        }
    }

    Action.cs 游戏操作的类型

    namespace InputHandlerDemo
    {
        static class Actions
        {
            // 自定义的操作类型
            public const string Jump = "Jump";
            public const string Exit = "Exit";
            public const string Up = "Up";
            public const string Pause = "Pause";
        }
    }

    下面是输入的操作的封装类

    GameInput.cs

    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Input.Touch;
    
    
    namespace InputHandlerDemo.Inputs
    {
        /// <summary>
        /// 游戏输入管理类
        /// </summary>
        class GameInput
        {
            //输入类型字典
            Dictionary<string, Input> Inputs = new Dictionary<string, Input>();
            //获取输入类型
            public Input GetInput(string theAction)
            {
                //如果没有改类型的输入操作则添加一个
                if (Inputs.ContainsKey(theAction) == false)
                {
                    Inputs.Add(theAction, new Input());
                }
    
                return Inputs[theAction];
            }
    
            public void BeginUpdate()
            {
                Input.BeginUpdate();
            }
    
            public void EndUpdate()
            {
                Input.EndUpdate();
            }
    
            public bool IsConnected(PlayerIndex thePlayer)
            {
                // If there never WAS a gamepad connected, just say the gamepad is STILL connected
                if (Input.GamepadConnectionState[thePlayer] == false)
                    return true;
    
                return Input.IsConnected(thePlayer);
            }
    
            public bool IsPressed(string theAction)
            {
                if (!Inputs.ContainsKey(theAction))
                {
                    return false;
                }
    
                return Inputs[theAction].IsPressed(PlayerIndex.One);
            }
            /// <summary>
            /// 判断单击的状态
            /// </summary>
            /// <param name="theAction">动作</param>
            /// <param name="thePlayer">玩家</param>
            /// <returns></returns>
            public bool IsPressed(string theAction, PlayerIndex thePlayer)
            {
                if (Inputs.ContainsKey(theAction) == false)
                {
                    return false;
                }
    
                return Inputs[theAction].IsPressed(thePlayer);
            }
    
            public bool IsPressed(string theAction, PlayerIndex? thePlayer)
            {
                if (thePlayer == null)
                {
                    PlayerIndex theReturnedControllingPlayer;
                    return IsPressed(theAction, thePlayer, out theReturnedControllingPlayer);
                }
    
                return IsPressed(theAction, (PlayerIndex)thePlayer);
            }
    
            public bool IsPressed(string theAction, PlayerIndex? thePlayer, out PlayerIndex theControllingPlayer)
            {
                if (!Inputs.ContainsKey(theAction))
                {
                    theControllingPlayer = PlayerIndex.One;
                    return false;
                }
    
                if (thePlayer == null)
                {
                    if (IsPressed(theAction, PlayerIndex.One))
                    {
                        theControllingPlayer = PlayerIndex.One;
                        return true;
                    }
    
                    if (IsPressed(theAction, PlayerIndex.Two))
                    {
                        theControllingPlayer = PlayerIndex.Two;
                        return true;
                    }
    
                    if (IsPressed(theAction, PlayerIndex.Three))
                    {
                        theControllingPlayer = PlayerIndex.Three;
                        return true;
                    }
    
                    if (IsPressed(theAction, PlayerIndex.Four))
                    {
                        theControllingPlayer = PlayerIndex.Four;
                        return true;
                    }
    
                    theControllingPlayer = PlayerIndex.One;
                    return false;
                }
    
                theControllingPlayer = (PlayerIndex)thePlayer;
                return IsPressed(theAction, (PlayerIndex)thePlayer);
            }
    
            public void AddGamePadInput(string theAction, Buttons theButton,
                                bool isReleasedPreviously)
            {
                GetInput(theAction).AddGamepadInput(theButton, isReleasedPreviously);
            }
    
            public void AddTouchTapInput(string theAction, Rectangle theTouchArea,
                                         bool isReleasedPreviously)
            {
                GetInput(theAction).AddTouchTapInput(theTouchArea, isReleasedPreviously);
            }
    
            public void AddTouchSlideInput(string theAction, Input.Direction theDirection,
                                           float slideDistance)
            {
                GetInput(theAction).AddTouchSlideInput(theDirection, slideDistance);
            }
    
            public void AddKeyboardInput(string theAction, Keys theKey,
                                         bool isReleasedPreviously)
            {
                GetInput(theAction).AddKeyboardInput(theKey, isReleasedPreviously);
            }
    
            public void AddTouchGestureInput(string theAction, GestureType theGesture,
                                             Rectangle theRectangle)
            {
                GetInput(theAction).AddTouchGesture(theGesture, theRectangle);
            }
    
            public void AddAccelerometerInput(string theAction, Input.Direction theDirection,
                                              float tiltThreshold)
            {
                GetInput(theAction).AddAccelerometerInput(theDirection, tiltThreshold);
            }
    
            public Vector2 CurrentGesturePosition(string theAction)
            {
                return GetInput(theAction).CurrentGesturePosition();
            }
    
            public Vector2 CurrentGestureDelta(string theAction)
            {
                return GetInput(theAction).CurrentGestureDelta();
            }
    
            public Vector2 CurrentGesturePosition2(string theAction)
            {
                return GetInput(theAction).CurrentGesturePosition2();
            }
    
            public Vector2 CurrentGestureDelta2(string theAction)
            {
                return GetInput(theAction).CurrentGestureDelta2();
            }
    
            public Point CurrentTouchPoint(string theAction)
            {
                Vector2? currentPosition = GetInput(theAction).CurrentTouchPosition();
                if (currentPosition == null)
                {
                    return new Point(-1, -1);
                }
    
                return new Point((int)currentPosition.Value.X, (int)currentPosition.Value.Y);
            }
    
            public Vector2 CurrentTouchPosition(string theAction)
            {
                Vector2? currentTouchPosition = GetInput(theAction).CurrentTouchPosition();
                if (currentTouchPosition == null)
                {
                    return new Vector2(-1, -1);
                }
    
                return (Vector2)currentTouchPosition;
            }
    
            public float CurrentGestureScaleChange(string theAction)
            {
                // Scaling is dependent on the Pinch gesture. If no input has been setup for 
                // Pinch then just return 0 indicating no scale change has occurred.
                if (!GetInput(theAction).PinchGestureAvailable) return 0;
    
                // Get the current and previous locations of the two fingers
                Vector2 currentPositionFingerOne = CurrentGesturePosition(theAction);
                Vector2 previousPositionFingerOne
                    = CurrentGesturePosition(theAction) - CurrentGestureDelta(theAction);
                Vector2 currentPositionFingerTwo = CurrentGesturePosition2(theAction);
                Vector2 previousPositionFingerTwo
                    = CurrentGesturePosition2(theAction) - CurrentGestureDelta2(theAction);
    
                // Figure out the distance between the current and previous locations
                float currentDistance = Vector2.Distance(currentPositionFingerOne, currentPositionFingerTwo);
                float previousDistance
                    = Vector2.Distance(previousPositionFingerOne, previousPositionFingerTwo);
    
                // Calculate the difference between the two and use that to alter the scale
                float scaleChange = (currentDistance - previousDistance) * .01f;
                return scaleChange;
            }
    
            public Vector3 CurrentAccelerometerReading(string theAction)
            {
                return GetInput(theAction).CurrentAccelerometerReading;
            }
    
        }
    }

    GestureDefinition.cs

    using System;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Input.Touch;
    
    namespace InputHandlerDemo.Inputs
    {
        /// <summary>
        /// 手势定义
        /// </summary>
        class GestureDefinition
        {
            public GestureType Type;
            public Rectangle CollisionArea;
            public GestureSample Gesture;
            public Vector2 Delta;
            public Vector2 Delta2;
            public Vector2 Position;
            public Vector2 Position2;
    
            public GestureDefinition(GestureType theGestureType, Rectangle theGestureArea)
            {
                Gesture = new GestureSample(theGestureType, new TimeSpan(0),
                                            Vector2.Zero, Vector2.Zero,
                                            Vector2.Zero, Vector2.Zero);
                Type = theGestureType;
                CollisionArea = theGestureArea;
            }
    
            public GestureDefinition(GestureSample theGestureSample)
            {
                Gesture = theGestureSample;
                Type = theGestureSample.GestureType;
                CollisionArea = new Rectangle((int)theGestureSample.Position.X,
                                              (int)theGestureSample.Position.Y, 5, 5);
    
                Delta = theGestureSample.Delta;
                Delta2 = theGestureSample.Delta2;
                Position = theGestureSample.Position;
                Position2 = theGestureSample.Position2;
            }
    
        }
    }

    Input.cs

    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Input.Touch;
    using Microsoft.Xna.Framework;
    using Microsoft.Devices.Sensors;
    
    namespace InputHandlerDemo.Inputs
    {
        /// <summary>
        /// 输入操作类
        /// </summary>
        class Input
        {
            Dictionary<Keys, bool> keyboardInputs = new Dictionary<Keys, bool>();
            Dictionary<Buttons, bool> gamepadInputs = new Dictionary<Buttons, bool>();
            Dictionary<Rectangle, bool> touchTapInputs = new Dictionary<Rectangle, bool>();
            Dictionary<Direction, float> touchSlideInputs = new Dictionary<Direction, float>();
            Dictionary<int, GestureDefinition> gestureInputs = new Dictionary<int, GestureDefinition>();
            Dictionary<Direction, float> accelerometerInputs = new Dictionary<Direction, float>();
    
            static public Dictionary<PlayerIndex, GamePadState> CurrentGamePadState//当前玩家的控制状态
        = new Dictionary<PlayerIndex, GamePadState>();
    
            static public Dictionary<PlayerIndex, GamePadState> PreviousGamePadState//上一个玩家的控制状态
                = new Dictionary<PlayerIndex, GamePadState>();
    
            static public TouchCollection CurrentTouchLocationState;//当前的触控集合
            static public TouchCollection PreviousTouchLocationState;//上一个触控集合
            static public KeyboardState CurrentKeyboardState;//当前的键盘状态
            static public KeyboardState PreviousKeyboardState;//上一个键盘状态
    
            static public Dictionary<PlayerIndex, bool> GamepadConnectionState
        = new Dictionary<PlayerIndex, bool>();
    
            static private List<GestureDefinition> detectedGestures = new List<GestureDefinition>();
    
    
            static private Accelerometer accelerometerSensor;
            static private Vector3 currentAccelerometerReading;
            //方向
            public enum Direction
            {
                Up,
                Down,
                Left,
                Right
            }
    
            public Input()
            {
                if (CurrentGamePadState.Count == 0)
                {
                    CurrentGamePadState.Add(PlayerIndex.One, GamePad.GetState(PlayerIndex.One));
                    CurrentGamePadState.Add(PlayerIndex.Two, GamePad.GetState(PlayerIndex.Two));
                    CurrentGamePadState.Add(PlayerIndex.Three, GamePad.GetState(PlayerIndex.Three));
                    CurrentGamePadState.Add(PlayerIndex.Four, GamePad.GetState(PlayerIndex.Four));
    
                    PreviousGamePadState.Add(PlayerIndex.One, GamePad.GetState(PlayerIndex.One));
                    PreviousGamePadState.Add(PlayerIndex.Two, GamePad.GetState(PlayerIndex.Two));
                    PreviousGamePadState.Add(PlayerIndex.Three, GamePad.GetState(PlayerIndex.Three));
                    PreviousGamePadState.Add(PlayerIndex.Four, GamePad.GetState(PlayerIndex.Four));
    
                    GamepadConnectionState.Add(PlayerIndex.One,
                        CurrentGamePadState[PlayerIndex.One].IsConnected);
                    GamepadConnectionState.Add(PlayerIndex.Two,
                        CurrentGamePadState[PlayerIndex.Two].IsConnected);
                    GamepadConnectionState.Add(PlayerIndex.Three,
                        CurrentGamePadState[PlayerIndex.Three].IsConnected);
                    GamepadConnectionState.Add(PlayerIndex.Four,
                        CurrentGamePadState[PlayerIndex.Four].IsConnected);
                }
                //添加重力感应
                if (accelerometerSensor == null)
                {
                    accelerometerSensor = new Accelerometer();
                    accelerometerSensor.ReadingChanged
                        += new EventHandler<AccelerometerReadingEventArgs>(AccelerometerReadingChanged);
                }
            }
            /// <summary>
            /// 开始更新
            /// </summary>
            static public void BeginUpdate()
            {
                //PlayerIndex游戏玩家的索引,添加4个玩家
                CurrentGamePadState[PlayerIndex.One] = GamePad.GetState(PlayerIndex.One);
                CurrentGamePadState[PlayerIndex.Two] = GamePad.GetState(PlayerIndex.Two);
                CurrentGamePadState[PlayerIndex.Three] = GamePad.GetState(PlayerIndex.Three);
                CurrentGamePadState[PlayerIndex.Four] = GamePad.GetState(PlayerIndex.Four);
                //当前触摸的地方
                CurrentTouchLocationState = TouchPanel.GetState();
                //玩家1的状态
                CurrentKeyboardState = Keyboard.GetState(PlayerIndex.One);
    
                detectedGestures.Clear();
                while (TouchPanel.IsGestureAvailable)
                {
                    GestureSample gesture = TouchPanel.ReadGesture();
                    detectedGestures.Add(new GestureDefinition(gesture));
                }
            }
            /// <summary>
            /// 结束更新
            /// </summary>
            static public void EndUpdate()
            {
                //PlayerIndex游戏玩家的索引,日安家
                PreviousGamePadState[PlayerIndex.One] = CurrentGamePadState[PlayerIndex.One];
                PreviousGamePadState[PlayerIndex.Two] = CurrentGamePadState[PlayerIndex.Two];
                PreviousGamePadState[PlayerIndex.Three] = CurrentGamePadState[PlayerIndex.Three];
                PreviousGamePadState[PlayerIndex.Four] = CurrentGamePadState[PlayerIndex.Four];
    
                PreviousTouchLocationState = CurrentTouchLocationState;
                PreviousKeyboardState = CurrentKeyboardState;
            }
    
            private void AccelerometerReadingChanged(object sender, AccelerometerReadingEventArgs e)
            {
                currentAccelerometerReading.X = (float)e.X;
                currentAccelerometerReading.Y = (float)e.Y;
                currentAccelerometerReading.Z = (float)e.Z;
            }
            // 添加一个键盘输入
            public void AddKeyboardInput(Keys theKey, bool isReleasedPreviously)
            {
                if (keyboardInputs.ContainsKey(theKey))
                {
                    keyboardInputs[theKey] = isReleasedPreviously;
                    return;
                }
                keyboardInputs.Add(theKey, isReleasedPreviously);
            }
            //添加一个游戏按钮输入
            public void AddGamepadInput(Buttons theButton, bool isReleasedPreviously)
            {
                if (gamepadInputs.ContainsKey(theButton))
                {
                    gamepadInputs[theButton] = isReleasedPreviously;
                    return;
                }
                gamepadInputs.Add(theButton, isReleasedPreviously);
            }
            //添加一个手势单击输入
            public void AddTouchTapInput(Rectangle theTouchArea, bool isReleasedPreviously)
            {
                if (touchTapInputs.ContainsKey(theTouchArea))
                {
                    touchTapInputs[theTouchArea] = isReleasedPreviously;
                    return;
                }
                touchTapInputs.Add(theTouchArea, isReleasedPreviously);
            }
            //添加一个手势滑动输入
            public void AddTouchSlideInput(Direction theDirection, float slideDistance)
            {
                if (touchSlideInputs.ContainsKey(theDirection))
                {
                    touchSlideInputs[theDirection] = slideDistance;
                    return;
                }
                touchSlideInputs.Add(theDirection, slideDistance);
            }
    
            public bool PinchGestureAvailable = false;//手势是否可用
            public void AddTouchGesture(GestureType theGesture, Rectangle theTouchArea)
            {
                TouchPanel.EnabledGestures = theGesture | TouchPanel.EnabledGestures;
                gestureInputs.Add(gestureInputs.Count, new GestureDefinition(theGesture, theTouchArea));
                if (theGesture == GestureType.Pinch)
                {
                    PinchGestureAvailable = true;
                }
            }
    
            static private bool isAccelerometerStarted = false;//重力加速是否可用
            public void AddAccelerometerInput(Direction direction, float tiltThreshold)
            {
                if (!isAccelerometerStarted)
                {
                    try
                    {
                        accelerometerSensor.Start();
                        isAccelerometerStarted = true;
                    }
                    catch (AccelerometerFailedException e)
                    {
                        isAccelerometerStarted = false;
                        System.Diagnostics.Debug.WriteLine(e.Message);
                    }
                }
    
                accelerometerInputs.Add(direction, tiltThreshold);
            }
    
            public void RemoveAccelerometerInputs()
            {
                if (isAccelerometerStarted)
                {
                    try
                    {
                        accelerometerSensor.Stop();
                        isAccelerometerStarted = false;
                    }
                    catch (AccelerometerFailedException e)
                    {
                        // The sensor couldn't be stopped.
                        System.Diagnostics.Debug.WriteLine(e.Message);
                    }
                }
    
                accelerometerInputs.Clear();
            }
    
    
            static public bool IsConnected(PlayerIndex thePlayerIndex)
            {
                return CurrentGamePadState[thePlayerIndex].IsConnected;
            }
    
            //是否选中玩家
            public bool IsPressed(PlayerIndex thePlayerIndex)
            {
                return IsPressed(thePlayerIndex, null);
            }
    
            public bool IsPressed(PlayerIndex thePlayerIndex, Rectangle? theCurrentObjectLocation)
            {
                if (IsKeyboardInputPressed())
                {
                    return true;
                }
    
                if (IsGamepadInputPressed(thePlayerIndex))
                {
                    return true;
                }
    
                if (IsTouchTapInputPressed())
                {
                    return true;
                }
    
                if (IsTouchSlideInputPressed())
                {
                    return true;
                }
                //点钟矩形区域
                if (IsGestureInputPressed(theCurrentObjectLocation))
                {
                    return true;
                }
    
                return false;
            }
    
            private bool IsKeyboardInputPressed()
            {
                foreach (Keys aKey in keyboardInputs.Keys)
                {
                    if (keyboardInputs[aKey]
                    && CurrentKeyboardState.IsKeyDown(aKey)
                    && !PreviousKeyboardState.IsKeyDown(aKey))
                    {
                        return true;
                    }
                    else if (!keyboardInputs[aKey]
                    && CurrentKeyboardState.IsKeyDown(aKey))
                    {
                        return true;
                    }
                }
    
                return false;
            }
    
    
            private bool IsGamepadInputPressed(PlayerIndex thePlayerIndex)
            {
                foreach (Buttons aButton in gamepadInputs.Keys)
                {
                    if (gamepadInputs[aButton]
                    && CurrentGamePadState[thePlayerIndex].IsButtonDown(aButton)
                    && !PreviousGamePadState[thePlayerIndex].IsButtonDown(aButton))
                    {
                        return true;
                    }
                    else if (!gamepadInputs[aButton]
                    && CurrentGamePadState[thePlayerIndex].IsButtonDown(aButton))
                    {
                        return true;
                    }
                }
    
                return false;
            }
    
            private bool IsTouchTapInputPressed()
            {
                foreach (Rectangle touchArea in touchTapInputs.Keys)
                {
                    if (touchTapInputs[touchArea]
                    && touchArea.Intersects(CurrentTouchRectangle)
                    && PreviousTouchPosition() == null)
                    {
                        return true;
                    }
                    else if (!touchTapInputs[touchArea]
                    && touchArea.Intersects(CurrentTouchRectangle))
                    {
                        return true;
                    }
                }
    
                return false;
            }
    
            private bool IsTouchSlideInputPressed()
            {
                foreach (Direction slideDirection in touchSlideInputs.Keys)
                {
                    if (CurrentTouchPosition() != null && PreviousTouchPosition() != null)
                    {
                        switch (slideDirection)
                        {
                            case Direction.Up:
                                {
                                    if (CurrentTouchPosition().Value.Y + touchSlideInputs[slideDirection]
                                        < PreviousTouchPosition().Value.Y)
                                    {
                                        return true;
                                    }
                                    break;
                                }
    
                            case Direction.Down:
                                {
                                    if (CurrentTouchPosition().Value.Y - touchSlideInputs[slideDirection]
                                        > PreviousTouchPosition().Value.Y)
                                    {
                                        return true;
                                    }
                                    break;
                                }
    
                            case Direction.Left:
                                {
                                    if (CurrentTouchPosition().Value.X + touchSlideInputs[slideDirection]
                                        < PreviousTouchPosition().Value.X)
                                    {
                                        return true;
                                    }
                                    break;
                                }
    
                            case Direction.Right:
                                {
                                    if (CurrentTouchPosition().Value.X - touchSlideInputs[slideDirection]
                                        > PreviousTouchPosition().Value.X)
                                    {
                                        return true;
                                    }
                                    break;
                                }
                        }
                    }
                }
    
                return false;
            }
    
            private bool IsGestureInputPressed(Rectangle? theNewDetectionLocation)
            {
                currentGestureDefinition = null;
    
                if (detectedGestures.Count == 0) return false;
    
                // Check to see if any of the Gestures defined in the gestureInputs 
                // dictionary have been performed and detected.
                foreach (GestureDefinition userDefinedGesture in gestureInputs.Values)
                {
                    foreach (GestureDefinition detectedGesture in detectedGestures)
                    {
                        if (detectedGesture.Type == userDefinedGesture.Type)
                        {
                            // If a Rectangle area to check against has been passed in, then
                            // use that one, otherwise use the one originally defined
                            Rectangle areaToCheck = userDefinedGesture.CollisionArea;
                            if (theNewDetectionLocation != null)
                                areaToCheck = (Rectangle)theNewDetectionLocation;
    
                            // If the gesture detected was made in the area where users were
                            // interested in Input (they intersect), then a gesture input is
                            // considered detected.
                            if (detectedGesture.CollisionArea.Intersects(areaToCheck))
                            {
                                if (currentGestureDefinition == null)
                                {
                                    currentGestureDefinition
                                        = new GestureDefinition(detectedGesture.Gesture);
                                }
                                else
                                {
                                    // Some gestures like FreeDrag and Flick are registered many, 
                                    // many times in a single Update frame. Since there is only 
                                    // one variable to store the gesture info, you must add on
                                    // any additional gesture values so there is a combination 
                                    // of all the gesture information in currentGesture
                                    currentGestureDefinition.Delta += detectedGesture.Delta;
                                    currentGestureDefinition.Delta2 += detectedGesture.Delta2;
                                    currentGestureDefinition.Position += detectedGesture.Position;
                                    currentGestureDefinition.Position2 += detectedGesture.Position2;
                                }
                            }
                        }
                    }
                }
    
                if (currentGestureDefinition != null) return true;
    
                return false;
            }
    
            private bool IsAccelerometerInputPressed()
            {
                foreach (KeyValuePair<Direction, float> input in accelerometerInputs)
                {
                    switch (input.Key)
                    {
                        case Direction.Up:
                            {
                                if (Math.Abs(currentAccelerometerReading.Y) > input.Value
                                && currentAccelerometerReading.Y < 0)
                                {
                                    return true;
                                }
                                break;
                            }
    
                        case Direction.Down:
                            {
                                if (Math.Abs(currentAccelerometerReading.Y) > input.Value
                                && currentAccelerometerReading.Y > 0)
                                {
                                    return true;
                                }
                                break;
                            }
    
                        case Direction.Left:
                            {
                                if (Math.Abs(currentAccelerometerReading.X) > input.Value
                                && currentAccelerometerReading.X < 0)
                                {
                                    return true;
                                }
                                break;
                            }
    
                        case Direction.Right:
                            {
                                if (Math.Abs(currentAccelerometerReading.X) > input.Value
                                && currentAccelerometerReading.X > 0)
                                {
                                    return true;
                                }
                                break;
                            }
                    }
                }
    
                return false;
            }
    
            GestureDefinition currentGestureDefinition;
            public Vector2 CurrentGesturePosition()
            {
                if (currentGestureDefinition == null)
                    return Vector2.Zero;
    
                return currentGestureDefinition.Position;
            }
    
            public Vector2 CurrentGesturePosition2()
            {
                if (currentGestureDefinition == null)
                    return Vector2.Zero;
    
                return currentGestureDefinition.Position2;
            }
    
            public Vector2 CurrentGestureDelta()
            {
                if (currentGestureDefinition == null)
                    return Vector2.Zero;
    
                return currentGestureDefinition.Delta;
            }
    
            public Vector2 CurrentGestureDelta2()
            {
                if (currentGestureDefinition == null)
                    return Vector2.Zero;
    
                return currentGestureDefinition.Delta2;
            }
    
    
            public Vector2? CurrentTouchPosition()
            {
                foreach (TouchLocation location in CurrentTouchLocationState)
                {
                    switch (location.State)
                    {
                        case TouchLocationState.Pressed:
                            return location.Position;
    
                        case TouchLocationState.Moved:
                            return location.Position;
                    }
                }
    
                return null;
            }
    
            private Vector2? PreviousTouchPosition()
            {
                foreach (TouchLocation location in PreviousTouchLocationState)
                {
                    switch (location.State)
                    {
                        case TouchLocationState.Pressed:
                            return location.Position;
    
                        case TouchLocationState.Moved:
                            return location.Position;
                    }
                }
    
                return null;
            }
    
    
            private Rectangle CurrentTouchRectangle
            {
                get
                {
                    Vector2? touchPosition = CurrentTouchPosition();
                    if (touchPosition == null)
                        return Rectangle.Empty;
    
                    return new Rectangle((int)touchPosition.Value.X - 5,
                                         (int)touchPosition.Value.Y - 5,
                                         10,
                                         10);
                }
            }
    
    
            public Vector3 CurrentAccelerometerReading
            {
                get
                {
                    return currentAccelerometerReading;
                }
            }
        }
    }

    TouchIndicator.cs

    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input.Touch;
    using Microsoft.Xna.Framework.Content;
    
    
    namespace InputHandlerDemo.Inputs
    {
        /// <summary>
        /// 触控轨迹
        /// </summary>
        class TouchIndicator
        {
            int alphaValue = 255;
            public int TouchID;
    
            Texture2D touchCircleIndicatorTexture;
            Texture2D touchCrossHairIndicatorTexture;
            //轨迹集合
            List<Vector2> touchPositions = new List<Vector2>();
            /// <summary>
            /// 初始化触摸轨迹
            /// </summary>
            /// <param name="touchID"></param>
            /// <param name="content"></param>
            public TouchIndicator(int touchID, ContentManager content)
            {
                TouchID = touchID;
    
                touchCircleIndicatorTexture = content.Load<Texture2D>("Circle");
                touchCrossHairIndicatorTexture = content.Load<Texture2D>("Crosshair");
            }
    
            private Vector2? TouchPosition(TouchCollection touchLocationState)
            {
                TouchLocation touchLocation;
                if (touchLocationState.FindById(TouchID, out touchLocation))
                {
                    return touchLocation.Position;
                }
    
                return null;
            }
    
            public void Update(TouchCollection touchLocationState)
            {
                Vector2? currentPosition = TouchPosition(touchLocationState);
                if (currentPosition == null)
                {
                    if (touchPositions.Count > 0)
                    {
                        alphaValue -= 20;
                        if (alphaValue <= 0)
                        {
                            touchPositions.Clear();
                            alphaValue = 255;
                        }
                    }
                }
                else
                {
                    if (alphaValue != 255)
                    {
                        touchPositions.Clear();
                        alphaValue = 255;
                    }
    
                    touchPositions.Add((Vector2)currentPosition);
                }
            }
            /// <summary>
            /// 绘制界面
            /// </summary>
            /// <param name="batch"></param>
            public void Draw(SpriteBatch batch)
            {
                if (touchPositions.Count != 0)
                {
                    Vector2 previousPosition = touchPositions[0];
                    Vector2 offsetForCenteringTouchPosition = new Vector2(-25, 0);
                    //绘制触摸的轨迹
                    foreach (Vector2 aPosition in touchPositions)
                    {
                        DrawLine(batch,
                                 touchCircleIndicatorTexture,
                                 touchCrossHairIndicatorTexture,
                                 previousPosition + offsetForCenteringTouchPosition,
                                 aPosition + offsetForCenteringTouchPosition,
                                 new Color(0, 0, 255, alphaValue));
    
                        previousPosition = aPosition;
                    }
                }
            }
            /// <summary>
            /// 画线
            /// </summary>
            /// <param name="batch"></param>
            /// <param name="lineTexture"></param>
            /// <param name="touchTexture"></param>
            /// <param name="startingPoint"></param>
            /// <param name="endingPoint"></param>
            /// <param name="lineColor"></param>
            void DrawLine(SpriteBatch batch, Texture2D lineTexture, Texture2D touchTexture,
                  Vector2 startingPoint, Vector2 endingPoint, Color lineColor)
            {
                batch.Draw(touchTexture, startingPoint, lineColor);
    
                Vector2 difference = startingPoint - endingPoint;
                float lineLength = difference.Length() / 8;
    
                for (int i = 0; i < lineLength; i++)
                {
                    batch.Draw(lineTexture, startingPoint, lineColor);
                    startingPoint.X -= difference.X / lineLength;
                    startingPoint.Y -= difference.Y / lineLength;
                }
    
                batch.Draw(touchTexture, endingPoint, lineColor);
            }
        }
    }

    TouchIndicatorCollection.cs

    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Input.Touch;
    using Microsoft.Xna.Framework.Graphics;
    
    
    namespace InputHandlerDemo.Inputs
    {
        /// <summary>
        /// 触控轨迹集合
        /// </summary>
        class TouchIndicatorCollection
        {
            List<TouchIndicator> touchPositions = new List<TouchIndicator>();
            /// <summary>
            /// 更新游戏界面
            /// </summary>
            /// <param name="gameTime"></param>
            /// <param name="content"></param>
            public void Update(GameTime gameTime, ContentManager content)
            {
                //在XNA中,TouchPanel可以向我们提供大量关于触控操作的信息  获取触控的集合
                TouchCollection currentTouchLocationState = TouchPanel.GetState();
                foreach (TouchLocation location in currentTouchLocationState)
                {//获取触控的位置
                    bool isTouchIDAlreadyStored = false;
                    foreach (TouchIndicator indicator in touchPositions)
                    {
                        //如果触控的位置id存在则跳出整个循环
                        if (location.Id == indicator.TouchID)
                        {
                            isTouchIDAlreadyStored = true;
                            break;
                        }
                    }
    
                    if (!isTouchIDAlreadyStored)
                    {
                        //加入一个触控的位置
                        TouchIndicator indicator = new TouchIndicator(location.Id, content);
                        touchPositions.Add(indicator);
                    }
                }
    
                foreach (TouchIndicator indicator in touchPositions)
                {
                    indicator.Update(currentTouchLocationState);
                }
            }
    
            public void Draw(SpriteBatch batch)
            {
                foreach (TouchIndicator indicator in touchPositions)
                {
                    indicator.Draw(batch);
                }
            }
        }
    }

  • 相关阅读:
    Ubuntu下hadoop2.4搭建集群(单机模式)
    软考历程(2)——海明码校验
    key 串口
    android删除文件出错
    ORACLE 11G没有备份文件參数文件在异机通过rman备份恢复找回被误删的数据
    【SICP归纳】2 高阶函数和数据抽象
    Java加密算法 AES
    从BAE到SAE,从SAE又回到BAE
    velocity-字母序号 list
    Java 加密解密 对称加密算法 非对称加密算法 MD5 BASE64 AES RSA
  • 原文地址:https://www.cnblogs.com/linzheng/p/2469108.html
Copyright © 2020-2023  润新知