XNA Game Control Xbox360 & Keyboard

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • XNA Game Control Xbox360 & Keyboard

      Gute Tag liebe XNA Freunde

      Hiermit Release ich für euch die Xbox360 & Keyboard Controll Funktion.
      Es ist schon alles perfekt eingestellt. Ihr müsst es nur noch an eurem
      XNA Game anpassen.


      "Code"

      Quellcode

      1. /*//---------------------------------------------------//
      2. * GameControl.cs *
      3. * Microsoft XNA Game Platform *
      4. * Adventure of Kanaarh *
      5. * Copyright (C) Jok3r *
      6. * Copyright (C) Kevin Kaymak. All rights reserved *
      7. *///--------------------------------------------------//
      9. using System;
      10. using System.Collections.Generic;
      11. using Microsoft.Xna.Framework;
      12. using Microsoft.Xna.Framework.Input;
      14. namespace AdventureofK
      15. {
      16. public static class GameControl
      17. {
      18. public enum Action
      19. {
      20. MainMenu,
      21. Ok,
      22. Back,
      23. CharackterManagment,
      24. Exit,
      25. TakeView,
      26. DropUnEquip,
      27. MoveUp,
      28. MoveDown,
      29. MoveLeft,
      30. MoveRight,
      31. CursorUp,
      32. CursorDown,
      33. DecreaseAmount,
      34. IncreaseAmount,
      35. PageLeft,
      36. PageRight,
      37. TargetUp,
      38. TargetDown,
      39. ActiveLeft,
      40. ActiveRight,
      41. TotalActionCount,
      42. }
      44. private static readonly string[] actionNames =
      45. {
      46. "Haupt Menü",
      47. "Ok",
      48. "Zurück",
      49. "Charackter Auswahl",
      50. "Spiel Beenden",
      51. "Nehmen/Ansehen",
      52. "Drop/Unequip",
      53. "Move - Up",
      54. "Move - Down",
      55. "Move - Right",
      56. "Move Cursor - Up",
      57. "Move Cursor - Down",
      58. "Decrease Amount",
      59. "Increase Amount",
      60. "Page Left",
      61. "Page Right",
      62. "Target Up",
      63. "Target Down",
      64. "Select Char Left",
      65. "Select Char Right",
      66. };
      67. public static string GetActionName(Action action)
      68. {
      69. int index = (int)action;
      70. if ((index < 0) || (index > actionNames.Length))
      71. {
      72. throw new ArgumentException("action");
      73. }
      74. return actionNames[index];
      75. }
      77. public enum GamePadButtons
      78. {
      79. Start,
      80. Back,
      81. A,
      82. B,
      83. X,
      84. Y,
      85. Up,
      86. Down,
      87. Left,
      88. Right,
      89. LeftSchoulder,
      90. RightSchoulder,
      91. LeftTrigger,
      92. RightTrigger,
      93. }
      95. public class ActionMap
      96. {
      97. public List<GamePadButtons> gamePadButtons = new List<GamePadButtons>();
      98. public List<Keys> keyboardKeys = new List<Keys>();
      99. }
      101. const float analogLimit = 0.5f;
      103. public static KeyboardState currentKeyboardState;
      104. public static KeyboardState CurrentKeyboardState
      105. {
      106. get { return currentKeyboardState; }
      107. }
      109. private static KeyboardState previousKeyboardState;
      110. public static bool IsKeyPressed(Keys key)
      111. {
      112. return currentKeyboardState.IsKeyDown(key);
      113. }
      115. public static bool IsKeyTriggered(Keys key)
      116. {
      117. return (currentKeyboardState.IsKeyDown(key)) &&
      118. (!previousKeyboardState.IsKeyDown(key));
      119. }
      121. //GamePad Controlls
      123. private static GamePadState currentGamePadState;
      124. private static GamePadState CurrentGamePadState
      125. {
      126. get { return currentGamePadState; }
      127. }
      129. private static GamePadState previousGamePadState;
      130. public static bool IsGamePadStartPressed()
      131. {
      132. return (currentGamePadState.Buttons.Start == ButtonState.Pressed);
      133. }
      135. public static bool IsGamePadBackPressed()
      136. {
      137. return (currentGamePadState.Buttons.Back == ButtonState.Pressed);
      138. }
      140. public static bool IsGamePadAPressed()
      141. {
      142. return (currentGamePadState.Buttons.A == ButtonState.Pressed);
      143. }
      145. public static bool IsGamePadBPressed()
      146. {
      147. return (currentGamePadState.Buttons.B == ButtonState.Pressed);
      148. }
      150. public static bool IsGamePadXPressed()
      151. {
      152. return (currentGamePadState.Buttons.X == ButtonState.Pressed);
      153. }
      155. public static bool IsGamePadYkPressed()
      156. {
      157. return (currentGamePadState.Buttons.Y == ButtonState.Pressed);
      158. }
      160. public static bool IsGamePadLeftShoulderPressed()
      161. {
      162. return (currentGamePadState.Buttons.LeftShoulder == ButtonState.Pressed);
      163. }
      165. public static bool IsGamePadRightShoulderPressed()
      166. {
      167. return (currentGamePadState.Buttons.RightShoulder == ButtonState.Pressed);
      168. }
      170. public static bool IsGamePadDPadDownPressed()
      171. {
      172. return (currentGamePadState.DPad.Down == ButtonState.Pressed);
      173. }
      175. public static bool IsGamePadDPadUpPressed()
      176. {
      177. return (currentGamePadState.DPad.Up == ButtonState.Pressed);
      178. }
      180. public static bool IsGamePadDPadLeftPressed()
      181. {
      182. return (currentGamePadState.DPad.Left == ButtonState.Pressed);
      183. }
      185. public static bool IsGamePadDPadRightPressed()
      186. {
      187. return (currentGamePadState.DPad.Right == ButtonState.Pressed);
      188. }
      190. public static bool IsGamePadLeftTriggerPressed()
      191. {
      192. return (currentGamePadState.Triggers.Left > analogLimit);
      193. }
      195. public static bool IsGamePadRightTriggerPressed()
      196. {
      197. return (currentGamePadState.Triggers.Right > analogLimit);
      198. }
      200. public static bool IsGamePadLeftStickUpPressed()
      201. {
      202. return (currentGamePadState.ThumbSticks.Left.Y > analogLimit);
      203. }
      205. public static bool IsGamePadLeftStickDownPressed()
      206. {
      207. return (-1f * currentGamePadState.ThumbSticks.Left.Y > analogLimit);
      208. }
      210. public static bool IsGamePadLeftStickLeftPressed()
      211. {
      212. return (-1f * currentGamePadState.ThumbSticks.Left.X > analogLimit);
      213. }
      215. public static bool IsGamePadLeftStickRightPressed()
      216. {
      217. return (currentGamePadState.ThumbSticks.Left.X > analogLimit);
      218. }
      220. private static bool IsGamePadButtonsPressed(GamePadButtons gamePadKey)
      221. {
      222. switch (gamePadKey)
      223. {
      224. case GamePadButtons.Start:
      225. return IsGamePadStartPressed();
      227. case GamePadButtons.Back:
      228. return IsGamePadBackPressed();
      231. case GamePadButtons.A:
      232. return IsGamePadAPressed();
      235. case GamePadButtons.B:
      236. return IsGamePadBPressed();
      239. case GamePadButtons.X:
      240. return IsGamePadXPressed();
      243. case GamePadButtons.LeftSchoulder:
      244. return IsGamePadLeftShoulderPressed();
      247. case GamePadButtons.RightSchoulder:
      248. return IsGamePadRightShoulderPressed();
      251. case GamePadButtons.LeftTrigger:
      252. return IsGamePadLeftTriggerPressed();
      255. case GamePadButtons.RightTrigger:
      256. return IsGamePadRightTriggerPressed();
      259. case GamePadButtons.Up:
      260. return IsGamePadDPadUpPressed() ||
      261. IsGamePadLeftStickUpPressed();
      263. case GamePadButtons.Down:
      264. return IsGamePadDPadDownPressed() ||
      265. IsGamePadLeftStickDownPressed();
      267. case GamePadButtons.Left:
      268. return IsGamePadDPadLeftPressed() ||
      269. IsGamePadLeftStickLeftPressed();
      271. case GamePadButtons.Right:
      272. return IsGamePadDPadRightPressed() ||
      273. IsGamePadLeftStickRightPressed();
      274. }
      276. return false;
      277. }
      279. //Gamepad Triggers
      281. public static bool IsGamePadStartTriggered()
      282. {
      283. return ((currentGamePadState.Buttons.Start == ButtonState.Pressed) &&
      284. (previousGamePadState.Buttons.Start == ButtonState.Released));
      285. }
      287. public static bool IsGamePadBackTriggered()
      288. {
      289. return ((currentGamePadState.Buttons.Back == ButtonState.Pressed) &&
      290. (previousGamePadState.Buttons.Back == ButtonState.Released));
      291. }
      293. public static bool IsGamePadATriggered()
      294. {
      295. return ((currentGamePadState.Buttons.A == ButtonState.Pressed) &&
      296. (previousGamePadState.Buttons.A == ButtonState.Released));
      297. }
      299. public static bool IsGamePadBTriggered()
      300. {
      301. return ((currentGamePadState.Buttons.B == ButtonState.Pressed) &&
      302. (previousGamePadState.Buttons.B == ButtonState.Released));
      303. }
      305. public static bool IsGamePadXTriggered()
      306. {
      307. return ((currentGamePadState.Buttons.X == ButtonState.Pressed) &&
      308. (previousGamePadState.Buttons.X == ButtonState.Released));
      309. }
      311. public static bool IsGamePadYTriggered()
      312. {
      313. return ((currentGamePadState.Buttons.Y == ButtonState.Pressed) &&
      314. (previousGamePadState.Buttons.Y == ButtonState.Released));
      315. }
      317. public static bool IsGamePadLeftShoulderTriggered()
      318. {
      319. return ((currentGamePadState.Buttons.LeftShoulder == ButtonState.Pressed) &&
      320. (previousGamePadState.Buttons.LeftShoulder == ButtonState.Released));
      321. }
      323. public static bool IsGamePadRightShoulderTriggered()
      324. {
      325. return ((currentGamePadState.Buttons.RightShoulder == ButtonState.Pressed) &&
      326. (previousGamePadState.Buttons.RightShoulder == ButtonState.Released));
      327. }
      329. public static bool IsGamePadDPatUpTriggered()
      330. {
      331. return ((currentGamePadState.DPad.Up == ButtonState.Pressed) &&
      332. (previousGamePadState.DPad.Up == ButtonState.Released));
      333. }
      335. public static bool IsGamePadDPatDownTriggered()
      336. {
      337. return ((currentGamePadState.DPad.Down == ButtonState.Pressed) &&
      338. (previousGamePadState.DPad.Down == ButtonState.Released));
      339. }
      341. public static bool IsGamePadDPatLeftTriggered()
      342. {
      343. return ((currentGamePadState.DPad.Left == ButtonState.Pressed) &&
      344. (previousGamePadState.DPad.Left == ButtonState.Released));
      345. }
      347. public static bool IsGamePadDPatRightTriggered()
      348. {
      349. return ((currentGamePadState.DPad.Right == ButtonState.Pressed) &&
      350. (previousGamePadState.DPad.Right == ButtonState.Released));
      351. }
      353. public static bool IsGamePadLeftTriggerTriggered()
      354. {
      355. return ((currentGamePadState.Triggers.Left > analogLimit) &&
      356. (previousGamePadState.Triggers.Left > analogLimit));
      357. }
      359. public static bool IsGamePadRightTriggerTriggered()
      360. {
      361. return ((currentGamePadState.Triggers.Right > analogLimit) &&
      362. (previousGamePadState.Triggers.Right > analogLimit));
      363. }
      365. public static bool IsGamePadLeftStickUpTriggered()
      366. {
      367. return ((currentGamePadState.ThumbSticks.Left.Y > analogLimit) &&
      368. (previousGamePadState.ThumbSticks.Left.Y > analogLimit));
      369. }
      371. public static bool IsGamePadLeftStickDownTriggered()
      372. {
      373. return ((-1f * currentGamePadState.ThumbSticks.Left.Y > analogLimit) &&
      374. (-1f * previousGamePadState.ThumbSticks.Left.Y > analogLimit));
      375. }
      377. public static bool IsGamePadLeftStickLeftTriggered()
      378. {
      379. return ((-1f * currentGamePadState.ThumbSticks.Left.X > analogLimit) &&
      380. (-1f * previousGamePadState.ThumbSticks.Left.X > analogLimit));
      381. }
      383. public static bool IsGamePadLeftStickRightTriggered()
      384. {
      385. return ((currentGamePadState.ThumbSticks.Left.X > analogLimit) &&
      386. (previousGamePadState.ThumbSticks.Left.X > analogLimit));
      387. }
      389. private static bool IsGamePadButtonTriggered(GamePadButtons gamePadKey)
      390. {
      391. switch (gamePadKey)
      392. {
      393. case GamePadButtons.Start:
      394. return IsGamePadStartTriggered();
      396. case GamePadButtons.Back:
      397. return IsGamePadBackTriggered();
      399. case GamePadButtons.A:
      400. return IsGamePadATriggered();
      402. case GamePadButtons.B:
      403. return IsGamePadBTriggered();
      405. case GamePadButtons.X:
      406. return IsGamePadXTriggered();
      408. case GamePadButtons.Y:
      409. return IsGamePadYTriggered();
      411. case GamePadButtons.LeftSchoulder:
      412. return IsGamePadLeftShoulderTriggered();
      414. case GamePadButtons.RightSchoulder:
      415. return IsGamePadRightShoulderTriggered();
      417. case GamePadButtons.LeftTrigger:
      418. return IsGamePadLeftTriggerTriggered();
      420. case GamePadButtons.RightTrigger:
      421. return IsGamePadRightTriggerTriggered();
      423. case GamePadButtons.Up:
      424. return IsGamePadDPatUpTriggered() ||
      425. IsGamePadLeftStickUpTriggered();
      427. case GamePadButtons.Down:
      428. return IsGamePadDPatDownTriggered() ||
      429. IsGamePadLeftStickDownTriggered();
      431. case GamePadButtons.Left:
      432. return IsGamePadDPatLeftTriggered() ||
      433. IsGamePadLeftStickLeftTriggered();
      435. case GamePadButtons.Right:
      436. return IsGamePadDPatRightTriggered() ||
      437. IsGamePadLeftStickRightTriggered();
      438. }
      439. return false;
      440. }
      442. //Action Mapping Game
      444. private static ActionMap[] actionMaps;
      446. public static ActionMap[] ActionMaps
      447. {
      448. get { return actionMaps; }
      449. }
      451. private static void ResetActionMaps()
      452. {
      453. actionMaps = new ActionMap[(int)Action.TotalActionCount];
      454. actionMaps[(int)Action.MainMenu] = new ActionMap();
      455. actionMaps[(int)Action.MainMenu].keyboardKeys.Add(Keys.Tab);
      456. actionMaps[(int)Action.MainMenu].gamePadButtons.Add(GamePadButtons.Start);
      457. actionMaps[(int)Action.Ok] = new ActionMap();
      458. actionMaps[(int)Action.Ok].keyboardKeys.Add(Keys.Enter);
      459. actionMaps[(int)Action.Ok].gamePadButtons.Add(GamePadButtons.A);
      460. actionMaps[(int)Action.Back] = new ActionMap();
      461. actionMaps[(int)Action.Back].keyboardKeys.Add(Keys.Escape);
      462. actionMaps[(int)Action.Back].gamePadButtons.Add(GamePadButtons.B);
      463. actionMaps[(int)Action.CharackterManagment] = new ActionMap();
      464. actionMaps[(int)Action.CharackterManagment].keyboardKeys.Add(Keys.Space);
      465. actionMaps[(int)Action.CharackterManagment].gamePadButtons.Add(GamePadButtons.Y);
      466. actionMaps[(int)Action.Exit] = new ActionMap();
      467. actionMaps[(int)Action.Exit].keyboardKeys.Add(Keys.Escape);
      468. actionMaps[(int)Action.Exit].gamePadButtons.Add(GamePadButtons.Back);
      469. actionMaps[(int)Action.TakeView] = new ActionMap();
      470. actionMaps[(int)Action.TakeView].keyboardKeys.Add(Keys.LeftControl);
      471. actionMaps[(int)Action.TakeView].gamePadButtons.Add(GamePadButtons.Y);
      472. actionMaps[(int)Action.DropUnEquip] = new ActionMap();
      473. actionMaps[(int)Action.DropUnEquip].keyboardKeys.Add(Keys.D);
      474. actionMaps[(int)Action.DropUnEquip].gamePadButtons.Add(GamePadButtons.X);
      475. actionMaps[(int)Action.MoveUp] = new ActionMap();
      476. actionMaps[(int)Action.MoveUp].keyboardKeys.Add(Keys.Up);
      477. actionMaps[(int)Action.MoveUp].gamePadButtons.Add(GamePadButtons.Up);
      478. actionMaps[(int)Action.MoveDown] = new ActionMap();
      479. actionMaps[(int)Action.MoveDown].keyboardKeys.Add(Keys.Down);
      480. actionMaps[(int)Action.MoveDown].gamePadButtons.Add(GamePadButtons.Down);
      481. actionMaps[(int)Action.MoveLeft] = new ActionMap();
      482. actionMaps[(int)Action.MoveLeft].keyboardKeys.Add(Keys.Left);
      483. actionMaps[(int)Action.MoveLeft].gamePadButtons.Add(GamePadButtons.Left);
      484. actionMaps[(int)Action.MoveRight] = new ActionMap();
      485. actionMaps[(int)Action.MoveRight].keyboardKeys.Add(Keys.Right);
      486. actionMaps[(int)Action.MoveRight].gamePadButtons.Add(GamePadButtons.Right);
      487. actionMaps[(int)Action.CursorUp] = new ActionMap();
      488. actionMaps[(int)Action.CursorUp].keyboardKeys.Add(Keys.Up);
      489. actionMaps[(int)Action.CursorUp].gamePadButtons.Add(GamePadButtons.Up);
      490. actionMaps[(int)Action.CursorDown] = new ActionMap();
      491. actionMaps[(int)Action.CursorDown].keyboardKeys.Add(Keys.Down);
      492. actionMaps[(int)Action.CursorDown].gamePadButtons.Add(GamePadButtons.Down);
      493. actionMaps[(int)Action.DecreaseAmount] = new ActionMap();
      494. actionMaps[(int)Action.DecreaseAmount].keyboardKeys.Add(Keys.Left);
      495. actionMaps[(int)Action.DecreaseAmount].gamePadButtons.Add(GamePadButtons.Left);
      496. actionMaps[(int)Action.IncreaseAmount] = new ActionMap();
      497. actionMaps[(int)Action.IncreaseAmount].keyboardKeys.Add(Keys.Right);
      498. actionMaps[(int)Action.IncreaseAmount].gamePadButtons.Add(GamePadButtons.Right);
      499. actionMaps[(int)Action.PageLeft] = new ActionMap();
      500. actionMaps[(int)Action.PageLeft].keyboardKeys.Add(Keys.LeftShift);
      501. actionMaps[(int)Action.PageLeft].gamePadButtons.Add(GamePadButtons.LeftTrigger);
      502. actionMaps[(int)Action.PageRight] = new ActionMap();
      503. actionMaps[(int)Action.PageRight].keyboardKeys.Add(Keys.RightShift);
      504. actionMaps[(int)Action.PageRight].gamePadButtons.Add(GamePadButtons.RightTrigger);
      505. actionMaps[(int)Action.TargetUp] = new ActionMap();
      506. actionMaps[(int)Action.TargetUp].keyboardKeys.Add(Keys.Up);
      507. actionMaps[(int)Action.TargetUp].gamePadButtons.Add(GamePadButtons.Up);
      508. actionMaps[(int)Action.TargetDown] = new ActionMap();
      509. actionMaps[(int)Action.TargetDown].keyboardKeys.Add(Keys.Down);
      510. actionMaps[(int)Action.TargetDown].gamePadButtons.Add(GamePadButtons.Down);
      511. actionMaps[(int)Action.ActiveLeft] = new ActionMap();
      512. actionMaps[(int)Action.ActiveLeft].keyboardKeys.Add(Keys.Left);
      513. actionMaps[(int)Action.ActiveLeft].gamePadButtons.Add(GamePadButtons.Left);
      514. actionMaps[(int)Action.ActiveRight] = new ActionMap();
      515. actionMaps[(int)Action.ActiveRight].keyboardKeys.Add(Keys.Right);
      516. actionMaps[(int)Action.ActiveRight].gamePadButtons.Add(GamePadButtons.Right);
      517. }
      519. public static bool IsActionPressed(Action action)
      520. {
      521. return IsActionMapPressed(actionMaps[(int)action]);
      522. }
      524. public static bool IsActionTriggered(Action action)
      525. {
      526. return IsActionMapTriggered(actionMaps[(int)action]);
      527. }
      529. private static bool IsActionMapPressed(ActionMap actionMap)
      530. {
      531. for (int i = 0; i < actionMap.keyboardKeys.Count; i++)
      532. {
      533. if (IsKeyPressed(actionMap.keyboardKeys[i]))
      534. {
      535. return true;
      536. }
      537. }
      538. if (currentGamePadState.IsConnected)
      539. {
      540. for (int i = 0; i < actionMap.gamePadButtons.Count; i++)
      541. {
      542. if (IsGamePadButtonsPressed(actionMap.gamePadButtons[i]))
      543. {
      544. return true;
      545. }
      546. }
      547. }
      548. return false;
      549. }
      551. private static bool IsActionMapTriggered(ActionMap actionMap)
      552. {
      553. for (int i = 0; i < actionMap.gamePadButtons.Count; i++)
      554. {
      555. if (IsGamePadButtonTriggered(actionMap.gamePadButtons[i]))
      556. {
      557. return true;
      558. }
      559. }
      561. if (currentGamePadState.IsConnected)
      562. {
      563. for (int i = 0; i < actionMap.gamePadButtons.Count; i++)
      564. {
      565. if (IsGamePadButtonTriggered(actionMap.gamePadButtons[i]))
      566. {
      567. return true;
      568. }
      569. }
      570. }
      571. return false;
      572. }
      574. public static void Initialize()
      575. {
      576. ResetActionMaps();
      577. }
      579. public static void Update()
      580. {
      581. //Update Keyboard
      582. previousKeyboardState = currentKeyboardState;
      583. currentKeyboardState = Keyboard.GetState();
      585. //Update Gamepade
      586. previousGamePadState = currentGamePadState;
      587. currentGamePadState = GamePad.GetState(PlayerIndex.One);
      588. }
      589. }
      590. }
      Alles anzeigen


      Ihr müsst nur euren Namespace anpassen.
      Auserdem müsst ihr in eurer Game.cs folgende dinge adden.

      im feld

      Quellcode

      1. [COLOR=red]protected override void Initialize[/COLOR]

      Quellcode

      1. protected override void Initialize()
      2. {
      5. [COLOR=red] GameControl.Initialize();[/COLOR]
      9. }
      und im feld

      Quellcode

      1. [COLOR=red]protected override void Update(GameTime gameTime)[/COLOR]

      Quellcode

      1. protected override void Update(GameTime gameTime)
      2. {
      3. [COLOR=red] GameControl.Update();[/COLOR]
      5. }
      und schon könnt ihr euren Xbox Controller benutzen und eure
      Tastaturbelegung anpassen!
      Für diesen Code habe ich ca 2 Tage harte Arbeit gebraucht.

      Es sind:
      -600 Zeilen
      -493 Absätze
      -20.564 Zeichen
      -1.143 Wörter
      Ich werde schauen das ich noch mehr solche Dateien Releasen werde, da ich
      ja weniger Zeit habe ein paar XNA Tutorials zu schreiben.

      Wer Support brauch bei diesem Code, kann sich gerne an mich wenden.

    • Werbung zur Unterstützung des Forums ( Bitte AddBlocker deaktivieren )