XNA游戏：各种输入测试 中

GestureDefinition.cs

1. using System;  
2. using Microsoft.Xna.Framework;  
3. using Microsoft.Xna.Framework.Input.Touch;  
4.  
5. namespace InputHandlerDemo.Inputs  
6. {  
7.     /// <summary> 
8.     /// 手势定义  
9.     /// </summary> 
10.     class GestureDefinition  
11.     {  
12.         public GestureType Type;  
13.         public Rectangle CollisionArea;  
14.         public GestureSample Gesture;  
15.         public Vector2 Delta;  
16.         public Vector2 Delta2;  
17.         public Vector2 Position;  
18.         public Vector2 Position2;  
19.  
20.         public GestureDefinition(GestureType theGestureType, Rectangle theGestureArea)  
21.         {  
22.             Gesture = new GestureSample(theGestureType, new TimeSpan(0),  
23.                                         Vector2.Zero, Vector2.Zero,  
24.                                         Vector2.Zero, Vector2.Zero);  
25.             Type = theGestureType;  
26.             CollisionArea = theGestureArea;  
27.         }  
28.  
29.         public GestureDefinition(GestureSample theGestureSample)  
30.         {  
31.             Gesture = theGestureSample;  
32.             Type = theGestureSample.GestureType;  
33.             CollisionArea = new Rectangle((int)theGestureSample.Position.X,  
34.                                           (int)theGestureSample.Position.Y, 5, 5);  
35.  
36.             Delta = theGestureSample.Delta;  
37.             Delta2 = theGestureSample.Delta2;  
38.             Position = theGestureSample.Position;  
39.             Position2 = theGestureSample.Position2;  
40.         }  
41.  
42.     }  
43. } 

Input.cs

1. using System;  
2. using System.Collections.Generic;  
3. using Microsoft.Xna.Framework.Input;  
4. using Microsoft.Xna.Framework.Input.Touch;  
5. using Microsoft.Xna.Framework;  
6. using Microsoft.Devices.Sensors;  
7.  
8. namespace InputHandlerDemo.Inputs  
9. {  
10.     /// <summary> 
11.     /// 输入操作类  
12.     /// </summary> 
13.     class Input  
14.     {  
15.         Dictionary<Keys, bool> keyboardInputs = new Dictionary<Keys, bool>();  
16.         Dictionary<Buttons, bool> gamepadInputs = new Dictionary<Buttons, bool>();  
17.         Dictionary<Rectangle, bool> touchTapInputs = new Dictionary<Rectangle, bool>();  
18.         Dictionary<Direction, float> touchSlideInputs = new Dictionary<Direction, float>();  
19.         Dictionary<int, GestureDefinition> gestureInputs = new Dictionary<int, GestureDefinition>();  
20.         Dictionary<Direction, float> accelerometerInputs = new Dictionary<Direction, float>();  
21.  
22.         static public Dictionary<PlayerIndex, GamePadState> CurrentGamePadState//当前玩家的控制状态  
23.     = new Dictionary<PlayerIndex, GamePadState>();  
24.  
25.         static public Dictionary<PlayerIndex, GamePadState> PreviousGamePadState//上一个玩家的控制状态  
26.             = new Dictionary<PlayerIndex, GamePadState>();  
27.  
28.         static public TouchCollection CurrentTouchLocationState;//当前的触控集合  
29.         static public TouchCollection PreviousTouchLocationState;//上一个触控集合  
30.         static public KeyboardState CurrentKeyboardState;//当前的键盘状态  
31.         static public KeyboardState PreviousKeyboardState;//上一个键盘状态  
32.  
33.         static public Dictionary<PlayerIndex, bool> GamepadConnectionState 
34.     = new Dictionary<PlayerIndex, bool>();  
35.  
36.         static private List<GestureDefinition> detectedGestures = new List<GestureDefinition>();  
37.  
38.  
39.         static private Accelerometer accelerometerSensor;  
40.         static private Vector3 currentAccelerometerReading;  
41.         //方向  
42.         public enum Direction  
43.         {  
44.             Up,  
45.             Down,  
46.             Left,  
47.             Right  
48.         }  
49.  
50.         public Input()  
51.         {  
52.             if (CurrentGamePadState.Count == 0)  
53.             {  
54.                 CurrentGamePadState.Add(PlayerIndex.One, GamePad.GetState(PlayerIndex.One));  
55.                 CurrentGamePadState.Add(PlayerIndex.Two, GamePad.GetState(PlayerIndex.Two));  
56.                 CurrentGamePadState.Add(PlayerIndex.Three, GamePad.GetState(PlayerIndex.Three));  
57.                 CurrentGamePadState.Add(PlayerIndex.Four, GamePad.GetState(PlayerIndex.Four));  
58.  
59.                 PreviousGamePadState.Add(PlayerIndex.One, GamePad.GetState(PlayerIndex.One));  
60.                 PreviousGamePadState.Add(PlayerIndex.Two, GamePad.GetState(PlayerIndex.Two));  
61.                 PreviousGamePadState.Add(PlayerIndex.Three, GamePad.GetState(PlayerIndex.Three));  
62.                 PreviousGamePadState.Add(PlayerIndex.Four, GamePad.GetState(PlayerIndex.Four));  
63.  
64.                 GamepadConnectionState.Add(PlayerIndex.One,  
65.                     CurrentGamePadState[PlayerIndex.One].IsConnected);  
66.                 GamepadConnectionState.Add(PlayerIndex.Two,  
67.                     CurrentGamePadState[PlayerIndex.Two].IsConnected);  
68.                 GamepadConnectionState.Add(PlayerIndex.Three,  
69.                     CurrentGamePadState[PlayerIndex.Three].IsConnected);  
70.                 GamepadConnectionState.Add(PlayerIndex.Four,  
71.                     CurrentGamePadState[PlayerIndex.Four].IsConnected);  
72.             }  
73.             //添加重力感应  
74.             if (accelerometerSensor == null)  
75.             {  
76.                 accelerometerSensor = new Accelerometer();  
77.                 accelerometerSensor.ReadingChanged  
78.                     += new EventHandler<AccelerometerReadingEventArgs>(AccelerometerReadingChanged);  
79.             }  
80.         }  
81.         /// <summary> 
82.         /// 开始更新  
83.         /// </summary> 
84.         static public void BeginUpdate()  
85.         {  
86.             //PlayerIndex游戏玩家的索引，添加4个玩家  
87.             CurrentGamePadState[PlayerIndex.One] = GamePad.GetState(PlayerIndex.One);  
88.             CurrentGamePadState[PlayerIndex.Two] = GamePad.GetState(PlayerIndex.Two);  
89.             CurrentGamePadState[PlayerIndex.Three] = GamePad.GetState(PlayerIndex.Three);  
90.             CurrentGamePadState[PlayerIndex.Four] = GamePad.GetState(PlayerIndex.Four);  
91.             //当前触摸的地方  
92.             CurrentTouchLocationState = TouchPanel.GetState();  
93.             //玩家1的状态  
94.             CurrentKeyboardState = Keyboard.GetState(PlayerIndex.One);  
95.  
96.             detectedGestures.Clear();  
97.             while (TouchPanel.IsGestureAvailable)  
98.             {  
99.                 GestureSample gesture = TouchPanel.ReadGesture();  
100.                 detectedGestures.Add(new GestureDefinition(gesture));  
101.             }  
102.         }  
103.         /// <summary> 
104.         /// 结束更新  
105.         /// </summary> 
106.         static public void EndUpdate()  
107.         {  
108.             //PlayerIndex游戏玩家的索引，日安家  
109.             PreviousGamePadState[PlayerIndex.One] = CurrentGamePadState[PlayerIndex.One];  
110.             PreviousGamePadState[PlayerIndex.Two] = CurrentGamePadState[PlayerIndex.Two];  
111.             PreviousGamePadState[PlayerIndex.Three] = CurrentGamePadState[PlayerIndex.Three];  
112.             PreviousGamePadState[PlayerIndex.Four] = CurrentGamePadState[PlayerIndex.Four];  
113.  
114.             PreviousTouchLocationState = CurrentTouchLocationState;  
115.             PreviousKeyboardState = CurrentKeyboardState;  
116.         }  
117.  
118.         private void AccelerometerReadingChanged(object sender, AccelerometerReadingEventArgs e)  
119.         {  
120.             currentAccelerometerReading.X = (float)e.X;  
121.             currentAccelerometerReading.Y = (float)e.Y;  
122.             currentAccelerometerReading.Z = (float)e.Z;  
123.         }  
124.         // 添加一个键盘输入  
125.         public void AddKeyboardInput(Keys theKey, bool isReleasedPreviously)  
126.         {  
127.             if (keyboardInputs.ContainsKey(theKey))  
128.             {  
129.                 keyboardInputs[theKey] = isReleasedPreviously;  
130.                 return;  
131.             }  
132.             keyboardInputs.Add(theKey, isReleasedPreviously);  
133.         }  
134.         //添加一个游戏按钮输入  
135.         public void AddGamepadInput(Buttons theButton, bool isReleasedPreviously)  
136.         {  
137.             if (gamepadInputs.ContainsKey(theButton))  
138.             {  
139.                 gamepadInputs[theButton] = isReleasedPreviously;  
140.                 return;  
141.             }  
142.             gamepadInputs.Add(theButton, isReleasedPreviously);  
143.         }  
144.         //添加一个手势单击输入  
145.         public void AddTouchTapInput(Rectangle theTouchArea, bool isReleasedPreviously)  
146.         {  
147.             if (touchTapInputs.ContainsKey(theTouchArea))  
148.             {  
149.                 touchTapInputs[theTouchArea] = isReleasedPreviously;  
150.                 return;  
151.             }  
152.             touchTapInputs.Add(theTouchArea, isReleasedPreviously);  
153.         }  
154.         //添加一个手势滑动输入  
155.         public void AddTouchSlideInput(Direction theDirection, float slideDistance)  
156.         {  
157.             if (touchSlideInputs.ContainsKey(theDirection))  
158.             {  
159.                 touchSlideInputs[theDirection] = slideDistance;  
160.                 return;  
161.             }  
162.             touchSlideInputs.Add(theDirection, slideDistance);  
163.         }  
164.  
165.         public bool PinchGestureAvailable = false;//手势是否可用  
166.         public void AddTouchGesture(GestureType theGesture, Rectangle theTouchArea)  
167.         {  
168.             TouchPanel.EnabledGestures = theGesture | TouchPanel.EnabledGestures;  
169.             gestureInputs.Add(gestureInputs.Count, new GestureDefinition(theGesture, theTouchArea));  
170.             if (theGesture == GestureType.Pinch)  
171.             {  
172.                 PinchGestureAvailable = true;  
173.             }  
174.         }  
175.  
176.         static private bool isAccelerometerStarted = false;//重力加速是否可用  
177.         public void AddAccelerometerInput(Direction direction, float tiltThreshold)  
178.         {  
179.             if (!isAccelerometerStarted)  
180.             {  
181.                 try  
182.                 {  
183.                     accelerometerSensor.Start();  
184.                     isAccelerometerStarted = true;  
185.                 }  
186.                 catch (AccelerometerFailedException e)  
187.                 {  
188.                     isAccelerometerStarted = false;  
189.                     System.Diagnostics.Debug.WriteLine(e.Message);  
190.                 }  
191.             }  
192.  
193.             accelerometerInputs.Add(direction, tiltThreshold);  
194.         }  
195.  
196.         public void RemoveAccelerometerInputs()  
197.         {  
198.             if (isAccelerometerStarted)  
199.             {  
200.                 try  
201.                 {  
202.                     accelerometerSensor.Stop();  
203.                     isAccelerometerStarted = false;  
204.                 }  
205.                 catch (AccelerometerFailedException e)  
206.                 {  
207.                     // The sensor couldn't be stopped.  
208.                     System.Diagnostics.Debug.WriteLine(e.Message);  
209.                 }  
210.             }  
211.  
212.             accelerometerInputs.Clear();  
213.         }  
214.  
215.  
216.         static public bool IsConnected(PlayerIndex thePlayerIndex)  
217.         {  
218.             return CurrentGamePadState[thePlayerIndex].IsConnected;  
219.         }  
220.  
221.         //是否选中玩家  
222.         public bool IsPressed(PlayerIndex thePlayerIndex)  
223.         {  
224.             return IsPressed(thePlayerIndex, null);  
225.         }  
226.  
227.         public bool IsPressed(PlayerIndex thePlayerIndex, Rectangle? theCurrentObjectLocation)  
228.         {  
229.             if (IsKeyboardInputPressed())  
230.             {  
231.                 return true;  
232.             }  
233.  
234.             if (IsGamepadInputPressed(thePlayerIndex))  
235.             {  
236.                 return true;  
237.             }  
238.  
239.             if (IsTouchTapInputPressed())  
240.             {  
241.                 return true;  
242.             }  
243.  
244.             if (IsTouchSlideInputPressed())  
245.             {  
246.                 return true;  
247.             }  
248.             //点钟矩形区域  
249.             if (IsGestureInputPressed(theCurrentObjectLocation))  
250.             {  
251.                 return true;  
252.             }  
253.  
254.             return false;  
255.         }  
256.  
257.         private bool IsKeyboardInputPressed()  
258.         {  
259.             foreach (Keys aKey in keyboardInputs.Keys)  
260.             {  
261.                 if (keyboardInputs[aKey]  
262.                 && CurrentKeyboardState.IsKeyDown(aKey)  
263.                 && !PreviousKeyboardState.IsKeyDown(aKey))  
264.                 {  
265.                     return true;  
266.                 }  
267.                 else if (!keyboardInputs[aKey]  
268.                 && CurrentKeyboardState.IsKeyDown(aKey))  
269.                 {  
270.                     return true;  
271.                 }  
272.             }  
273.  
274.             return false;  
275.         }  
276.  
277.  
278.         private bool IsGamepadInputPressed(PlayerIndex thePlayerIndex)  
279.         {  
280.             foreach (Buttons aButton in gamepadInputs.Keys)  
281.             {  
282.                 if (gamepadInputs[aButton]  
283.                 && CurrentGamePadState[thePlayerIndex].IsButtonDown(aButton)  
284.                 && !PreviousGamePadState[thePlayerIndex].IsButtonDown(aButton))  
285.                 {  
286.                     return true;  
287.                 }  
288.                 else if (!gamepadInputs[aButton]  
289.                 && CurrentGamePadState[thePlayerIndex].IsButtonDown(aButton))  
290.                 {  
291.                     return true;  
292.                 }  
293.             }  
294.  
295.             return false;  
296.         }  
297.  
298.         private bool IsTouchTapInputPressed()  
299.         {  
300.             foreach (Rectangle touchArea in touchTapInputs.Keys)  
301.             {  
302.                 if (touchTapInputs[touchArea]  
303.                 && touchArea.Intersects(CurrentTouchRectangle)  
304.                 && PreviousTouchPosition() == null)  
305.                 {  
306.                     return true;  
307.                 }  
308.                 else if (!touchTapInputs[touchArea]  
309.                 && touchArea.Intersects(CurrentTouchRectangle))  
310.                 {  
311.                     return true;  
312.                 }  
313.             }  
314.  
315.             return false;  
316.         }  
317.  
318.         private bool IsTouchSlideInputPressed()  
319.         {  
320.             foreach (Direction slideDirection in touchSlideInputs.Keys)  
321.             {  
322.                 if (CurrentTouchPosition() != null && PreviousTouchPosition() != null)  
323.                 {  
324.                     switch (slideDirection)  
325.                     {  
326.                         case Direction.Up:  
327.                             {  
328.                                 if (CurrentTouchPosition().Value.Y + touchSlideInputs[slideDirection]  
329.                                     < PreviousTouchPosition().Value.Y)  
330.                                 {  
331.                                     return true;  
332.                                 }  
333.                                 break;  
334.                             }  
335.  
336.                         case Direction.Down:  
337.                             {  
338.                                 if (CurrentTouchPosition().Value.Y - touchSlideInputs[slideDirection]  
339.                                     > PreviousTouchPosition().Value.Y)  
340.                                 {  
341.                                     return true;  
342.                                 }  
343.                                 break;  
344.                             }  
345.  
346.                         case Direction.Left:  
347.                             {  
348.                                 if (CurrentTouchPosition().Value.X + touchSlideInputs[slideDirection]  
349.                                     < PreviousTouchPosition().Value.X)  
350.                                 {  
351.                                     return true;  
352.                                 }  
353.                                 break;  
354.                             }  
355.  
356.                         case Direction.Right:  
357.                             {  
358.                                 if (CurrentTouchPosition().Value.X - touchSlideInputs[slideDirection]  
359.                                     > PreviousTouchPosition().Value.X)  
360.                                 {  
361.                                     return true;  
362.                                 }  
363.                                 break;  
364.                             }  
365.                     }  
366.                 }  
367.             }  
368.  
369.             return false;  
370.         }  
371.  
372.         private bool IsGestureInputPressed(Rectangle? theNewDetectionLocation)  
373.         {  
374.             currentGestureDefinition = null;  
375.  
376.             if (detectedGestures.Count == 0) return false;  
377.  
378.             // Check to see if any of the Gestures defined in the gestureInputs   
379.             // dictionary have been performed and detected.  
380.             foreach (GestureDefinition userDefinedGesture in gestureInputs.Values)  
381.             {  
382.                 foreach (GestureDefinition detectedGesture in detectedGestures)  
383.                 {  
384.                     if (detectedGesture.Type == userDefinedGesture.Type)  
385.                     {  
386.                         // If a Rectangle area to check against has been passed in, then  
387.                         // use that one, otherwise use the one originally defined  
388.                         Rectangle areaToCheck = userDefinedGesture.CollisionArea;  
389.                         if (theNewDetectionLocation != null)  
390.                             areaToCheck = (Rectangle)theNewDetectionLocation;  
391.  
392.                         // If the gesture detected was made in the area where users were  
393.                         // interested in Input (they intersect), then a gesture input is  
394.                         // considered detected.  
395.                         if (detectedGesture.CollisionArea.Intersects(areaToCheck))  
396.                         {  
397.                             if (currentGestureDefinition == null)  
398.                             {  
399.                                 currentGestureDefinition 
400.                                     = new GestureDefinition(detectedGesture.Gesture);  
401.                             }  
402.                             else  
403.                             {  
404.                                 // Some gestures like FreeDrag and Flick are registered many,   
405.                                 // many times in a single Update frame. Since there is only   
406.                                 // one variable to store the gesture info, you must add on  
407.                                 // any additional gesture values so there is a combination   
408.                                 // of all the gesture information in currentGesture  
409.                                 currentGestureDefinition.Delta += detectedGesture.Delta;  
410.                                 currentGestureDefinition.Delta2 += detectedGesture.Delta2;  
411.                                 currentGestureDefinition.Position += detectedGesture.Position;  
412.                                 currentGestureDefinition.Position2 += detectedGesture.Position2;  
413.                             }  
414.                         }  
415.                     }  
416.                 }  
417.             }  
418.  
419.             if (currentGestureDefinition != null) return true;  
420.  
421.             return false;  
422.         }  
423.  
424.         private bool IsAccelerometerInputPressed()  
425.         {  
426.             foreach (KeyValuePair<Direction, float> input in accelerometerInputs)  
427.             {  
428.                 switch (input.Key)  
429.                 {  
430.                     case Direction.Up:  
431.                         {  
432.                             if (Math.Abs(currentAccelerometerReading.Y) > input.Value  
433.                             && currentAccelerometerReading.Y < 0)  
434.                             {  
435.                                 return true;  
436.                             }  
437.                             break;  
438.                         }  
439.  
440.                     case Direction.Down:  
441.                         {  
442.                             if (Math.Abs(currentAccelerometerReading.Y) > input.Value  
443.                             && currentAccelerometerReading.Y > 0)  
444.                             {  
445.                                 return true;  
446.                             }  
447.                             break;  
448.                         }  
449.  
450.                     case Direction.Left:  
451.                         {  
452.                             if (Math.Abs(currentAccelerometerReading.X) > input.Value  
453.                             && currentAccelerometerReading.X < 0)  
454.                             {  
455.                                 return true;  
456.                             }  
457.                             break;  
458.                         }  
459.  
460.                     case Direction.Right:  
461.                         {  
462.                             if (Math.Abs(currentAccelerometerReading.X) > input.Value  
463.                             && currentAccelerometerReading.X > 0)  
464.                             {  
465.                                 return true;  
466.                             }  
467.                             break;  
468.                         }  
469.                 }  
470.             }  
471.  
472.             return false;  
473.         }  
474.  
475.         GestureDefinition currentGestureDefinition;  
476.         public Vector2 CurrentGesturePosition()  
477.         {  
478.             if (currentGestureDefinition == null)  
479.                 return Vector2.Zero;  
480.  
481.             return currentGestureDefinition.Position;  
482.         }  
483.  
484.         public Vector2 CurrentGesturePosition2()  
485.         {  
486.             if (currentGestureDefinition == null)  
487.                 return Vector2.Zero;  
488.  
489.             return currentGestureDefinition.Position2;  
490.         }  
491.  
492.         public Vector2 CurrentGestureDelta()  
493.         {  
494.             if (currentGestureDefinition == null)  
495.                 return Vector2.Zero;  
496.  
497.             return currentGestureDefinition.Delta;  
498.         }  
499.  
500.         public Vector2 CurrentGestureDelta2()  
501.         {  
502.             if (currentGestureDefinition == null)  
503.                 return Vector2.Zero;  
504.  
505.             return currentGestureDefinition.Delta2;  
506.         }  
507.  
508.  
509.         public Vector2? CurrentTouchPosition()  
510.         {  
511.             foreach (TouchLocation location in CurrentTouchLocationState)  
512.             {  
513.                 switch (location.State)  
514.                 {  
515.                     case TouchLocationState.Pressed:  
516.                         return location.Position;  
517.  
518.                     case TouchLocationState.Moved:  
519.                         return location.Position;  
520.                 }  
521.             }  
522.  
523.             return null;  
524.         }  
525.  
526.         private Vector2? PreviousTouchPosition()  
527.         {  
528.             foreach (TouchLocation location in PreviousTouchLocationState)  
529.             {  
530.                 switch (location.State)  
531.                 {  
532.                     case TouchLocationState.Pressed:  
533.                         return location.Position;  
534.  
535.                     case TouchLocationState.Moved:  
536.                         return location.Position;  
537.                 }  
538.             }  
539.  
540.             return null;  
541.         }  
542.  
543.  
544.         private Rectangle CurrentTouchRectangle  
545.         {  
546.             get  
547.             {  
548.                 Vector2? touchPosition = CurrentTouchPosition();  
549.                 if (touchPosition == null)  
550.                     return Rectangle.Empty;  
551.  
552.                 return new Rectangle((int)touchPosition.Value.X - 5,  
553.                                      (int)touchPosition.Value.Y - 5,  
554.                                      10,  
555.                                      10);  
556.             }  
557.         }  
558.  
559.  
560.         public Vector3 CurrentAccelerometerReading  
561.         {  
562.             get  
563.             {  
564.                 return currentAccelerometerReading;  
565.             }  
566.         }  
567.     }  
568. } 

本文转自linzheng 51CTO博客，原文链接:http://blog.51cto.com/linzheng/1078372