API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 24th, 2020
83
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 8.77 KB | None | 0 0
raw download clone embed print report
  1. //Name: Jason Hoteit
  2.  
  3. package ArayTicTacToe;
  4.  
  5. import java.util.Scanner;
  6. import java.util.Random;
  7.  
  8. public class ArayTicTacToe {
  9.  
  10. public static Random Rnd = new Random();
  11.  
  12. // *************************************
  13. // Aufgabe: Soll den nächsten Spieler
  14. // auswählen
  15. //
  16. // Datentyp: char
  17. // *************************************
  18.  
  19. public static char NächsterSpieler(char Spieler) {
  20.  
  21. if (Spieler == 'X') { // Wenn Spieler X dran war...
  22. return 'O'; // kommt Spieler O dran.
  23. } else {
  24. return 'X'; // Nach Spieler O kommt Spieler X
  25. }
  26. }
  27.  
  28. // *************************************
  29. // Aufgabe: Soll den Spieler der startet
  30. // zufällig festlegen
  31. //
  32. // Datentyp: int
  33. // *************************************
  34.  
  35. public static char RandomSpieler() {
  36.  
  37. int Zahl = Rnd.nextInt(2);
  38.  
  39. if (Zahl == 0) {
  40. return 'X';
  41. } else {
  42. return 'O';
  43. }
  44. }
  45.  
  46. // ******************************************
  47. // Aufgabe: Soll eine Level Auswahl
  48. // bieten (vs. Spieler, PC oder KI)
  49. //
  50. // Datentyp:
  51. // ******************************************
  52.  
  53. public static void LevelAuswahl() {
  54.  
  55. }
  56.  
  57. // *************************************
  58. // Aufgabe: Soll eine Runde Spieler vs.
  59. // PC erlauben
  60. //
  61. // Datentyp: int, char, char [][]
  62. // *************************************
  63.  
  64. public static void Fall2() {
  65.  
  66. int r = 0;
  67. char[][] z = new char[5][5];
  68. char p = RandomSpieler();
  69.  
  70. // Fall 2 Spieler vs. PC
  71.  
  72. while (r == 0) {
  73. System.out.println(p + " ist am zug");
  74. Eingabe(z, p);
  75. Ausgabe(z);
  76.  
  77. r = Auswertung(z);
  78. p = NächsterSpieler(p);
  79.  
  80. }
  81. if (r == 1) {
  82. System.out.println("Spieler X hat gewonnen");
  83. } else if (r == 2) {
  84. System.out.println("Spieler O hat gewonnen");
  85. } else {
  86. System.out.println("Unentschieden");
  87.  
  88. }
  89. }
  90.  
  91. // *************************************
  92. // Aufgabe: Soll eine Runde Spieler vs.
  93. // Spieler erlauben
  94. //
  95. // Datentyp: int, char, char [][]
  96. // *************************************
  97.  
  98. public static void Fall1() {
  99.  
  100. int r = 0;
  101. char[][] z = new char[5][5];
  102. char p = RandomSpieler();
  103.  
  104. // Fall 1 Spieler vs. Spieler
  105.  
  106. while (r == 0) {
  107. System.out.println(p + " ist am zug"); // Sagt welcher Spieler dran ist
  108. Eingabe(z, p);
  109. Ausgabe(z);
  110.  
  111. r = Auswertung(z);
  112. p = NächsterSpieler(p);
  113.  
  114. }
  115. if (r == 1) {
  116. System.out.println("Spieler X hat gewonnen");
  117. } else if (r == 2) {
  118. System.out.println("Spieler O hat gewonnen");
  119. } else {
  120. System.out.println("Unentschieden");
  121.  
  122. }
  123. }
  124.  
  125. // ********************************************
  126. // Aufgabe: Wenn 1 zurück, ist das Feld belegt
  127. // Wenn 0 zurück, ist das Feld frei
  128. //
  129. // Datentyp: char[][], int
  130. // *************************************
  131.  
  132. public static int TestFeld(char[][] x, int a, int b) {
  133.  
  134. if ((x[a][b] == 'X') || (x[a][b] == 'O')) {
  135. System.out.println("Das Feld ist belegt, bitte wähle ein anderes.");
  136. return 1;
  137. } else { // Checkt ob das Feld belegt ist oder nicht, Feld belegt = 1, nicht belegt = 0
  138. return 0;
  139. }
  140. }
  141.  
  142. // **************************************************
  143. // Rückagabe Integere: 0: Keiner hat gewonnen
  144. // 1: Spieler 1 (X) hat gewonnen
  145. // 2: Spieler 2 (O) hat gewonnen
  146. // **************************************************
  147.  
  148. public static int Auswertung(char[][] x) {
  149.  
  150. int h = 0;
  151. int erg = 0;
  152.  
  153. if ((x[0][0] == 'X') && (x[1][0] == 'X') && (x[2][0] == 'X')) {
  154. erg = 1;
  155. }
  156. if ((x[0][1] == 'X') && (x[1][1] == 'X') && (x[2][1] == 'X')) {
  157. erg = 1;
  158. }
  159. if ((x[0][2] == 'X') && (x[1][2] == 'X') && (x[2][2] == 'X')) { // 3 gleiche Zeichen in einer Zeile
  160. erg = 1;
  161. }
  162. if ((x[0][0] == 'X') && (x[0][1] == 'X') && (x[0][2] == 'X')) {
  163. erg = 1;
  164. }
  165. if ((x[1][0] == 'X') && (x[1][1] == 'X') && (x[1][2] == 'X')) {
  166. erg = 1;
  167. }
  168. if ((x[2][0] == 'X') && (x[2][1] == 'X') && (x[2][2] == 'X')) { // 3 gleiche Zeichen in einer Reihe
  169. erg = 1;
  170. }
  171. if ((x[0][0] == 'X') && (x[1][1] == 'X') && (x[2][2] == 'X')) {
  172. erg = 1;
  173. }
  174. if ((x[2][0] == 'X') && (x[1][1] == 'X') && (x[0][2] == 'X')) { // 3 gleiche Zeichen senkrecht
  175. erg = 1;
  176. }
  177.  
  178. if ((x[0][0] == 'O') && (x[1][0] == 'O') && (x[2][0] == 'O')) {
  179. erg = 2;
  180. }
  181. if ((x[0][1] == 'O') && (x[1][1] == 'O') && (x[2][1] == 'O')) {
  182. erg = 2;
  183. }
  184. if ((x[0][2] == 'O') && (x[1][2] == 'O') && (x[2][2] == 'O')) { // 3 gleiche Zeichen in einer Zeile
  185. erg = 2;
  186. }
  187. if ((x[0][0] == 'O') && (x[0][1] == 'O') && (x[0][2] == 'O')) {
  188. erg = 2;
  189. }
  190. if ((x[1][0] == 'O') && (x[1][1] == 'O') && (x[1][2] == 'O')) {
  191. erg = 2;
  192. }
  193. if ((x[2][0] == 'O') && (x[2][1] == 'O') && (x[2][2] == 'O')) { // 3 gleiche Zeichen in einer Reihe
  194. erg = 2;
  195. }
  196. if ((x[0][0] == 'O') && (x[1][1] == 'O') && (x[2][2] == 'O')) {
  197. erg = 2;
  198. }
  199. if ((x[2][0] == 'O') && (x[1][1] == 'O') && (x[0][2] == 'O')) { // 3 gleiche Zeichen senkrecht
  200. erg = 2;
  201. }
  202.  
  203. h = 0; // Alle Felder sind voll
  204.  
  205. for (int j = 0; j < 3; j++) {
  206.  
  207. for (int i = 0; i < 3; i++) { // Wiedergabe vom Feld
  208.  
  209. if (x[i][j] == 'X') {
  210.  
  211. } else if (x[i][j] == 'O') {
  212.  
  213. } else {
  214. h = 1; // Habe ein leeres Feld
  215. }
  216. }
  217. }
  218.  
  219. if (erg == 0) { // In erg steht 0 = Unentschieden, 1 = Spieler X hat gewonnen, 2 = Spieler O hat
  220. // gewonnen
  221. if (h == 1) {
  222. return erg;
  223.  
  224. } else {
  225. System.out.println("Das Spiel ist zu ende");
  226. return 3; // Spiel zu Ende
  227. }
  228. } else { // In erg steht 1 oder 2
  229. return erg;
  230. }
  231. }
  232.  
  233. // *****************************************
  234. // Aufgabe: Soll dem Spieler eine Eingabe
  235. // zum platzieren eines Zeichens
  236. // ermöglichen
  237. //
  238. // Datentyp: char [][]
  239. // *****************************************
  240.  
  241. public static void Eingabe(char[][] x, char c) {
  242.  
  243. int h = 0; // Variable vom Typ Integer
  244. int Fall; // Variable vom Typ Integer
  245. String inData; // variable vom typ String
  246.  
  247. char[][] y = new char[3][3]; // Hilfsaray zur Ausgabe der Zahlen je Feld
  248.  
  249. y[0][0] = '1';
  250. y[1][0] = '2';
  251. y[2][0] = '3';
  252.  
  253. y[0][1] = '4';
  254. y[1][1] = '5';
  255. y[2][1] = '6';
  256.  
  257. y[0][2] = '7';
  258. y[1][2] = '8';
  259. y[2][2] = '9'; // Ausgabe des Spielfeldes mit Nummern
  260.  
  261. Scanner scan = new Scanner(System.in); // Neues objekt vom Typ Scanner erstellen
  262.  
  263. do { // Hier hin zurück wenn Feld besetzt
  264.  
  265. Ausgabe(y);
  266. System.out.print("Bitte wähle ein Feld zwischen 1-9 aus: ");
  267.  
  268. inData = scan.nextLine(); // Dateneingabe
  269. Fall = Integer.parseInt(inData); //
  270.  
  271. switch (Fall) {
  272. case 1:
  273. h = TestFeld(x, 0, 0);
  274. break;
  275. case 2:
  276. h = TestFeld(x, 1, 0);
  277. break;
  278. case 3:
  279. h = TestFeld(x, 2, 0);
  280. break;
  281.  
  282. case 4:
  283. h = TestFeld(x, 0, 1);
  284. break;
  285. case 5:
  286. h = TestFeld(x, 1, 1);
  287. break;
  288. case 6:
  289. h = TestFeld(x, 2, 1);
  290. break;
  291.  
  292. case 7:
  293. h = TestFeld(x, 0, 2);
  294. break;
  295. case 8:
  296. h = TestFeld(x, 1, 2);
  297. break;
  298. case 9:
  299. h = TestFeld(x, 2, 2);
  300. break;
  301. }
  302. } while (h == 1); // Testen ob das Feld noch frei ist
  303.  
  304. switch (Fall) {
  305. case 1:
  306. x[0][0] = c;
  307. break;
  308. case 2:
  309. x[1][0] = c;
  310. break;
  311. case 3:
  312. x[2][0] = c;
  313. break;
  314.  
  315. case 4:
  316. x[0][1] = c;
  317. break;
  318. case 5:
  319. x[1][1] = c;
  320. break;
  321. case 6:
  322. x[2][1] = c;
  323. break;
  324.  
  325. case 7:
  326. x[0][2] = c;
  327. break;
  328. case 8:
  329. x[1][2] = c;
  330. break;
  331. case 9:
  332. x[2][2] = c;
  333. break;
  334. }
  335. scan.close();
  336.  
  337. }
  338.  
  339. // *************************************************
  340. // Aufgabe : Soll ein Tic Tac Toe Feld ausgeben
  341. //
  342. // Datentyp: char [][]
  343. // *************************************************
  344.  
  345. public static void Ausgabe(char[][] x) {
  346.  
  347. char[][] a = new char[5][5];
  348.  
  349. a[0][0] = x[0][0];
  350. a[1][0] = '│'; // Alt + 179 = │
  351. a[2][0] = x[1][0];
  352. a[3][0] = '│';
  353. a[4][0] = x[2][0]; // Erste Zeile des Feldes
  354.  
  355. a[0][1] = '─'; // Alt + 196 = ─
  356. a[1][1] = '┼'; // Alt + 197 = ┼
  357. a[2][1] = '─';
  358. a[3][1] = '┼';
  359. a[4][1] = '─'; // Zweite Zeile des Feldes
  360.  
  361. a[0][2] = x[0][1];
  362. a[1][2] = '│';
  363. a[2][2] = x[1][1];
  364. a[3][2] = '│';
  365. a[4][2] = x[2][1]; // Dritte Zeile des Feldes
  366.  
  367. a[0][3] = '─';
  368. a[1][3] = '┼';
  369. a[2][3] = '─';
  370. a[3][3] = '┼';
  371. a[4][3] = '─'; // Vierte Zeile des Feldes
  372.  
  373. a[0][4] = x[0][2];
  374. a[1][4] = '│';
  375. a[2][4] = x[1][2];
  376. a[3][4] = '│';
  377. a[4][4] = x[2][2];// Fünfte Zeile des Feldes
  378.  
  379. for (int j = 0; j < 5; j++) {
  380. for (int i = 0; i < 5; i++) { // Wiedergabe vom Feld
  381. System.out.print(a[i][j]);
  382. }
  383. System.out.println();
  384.  
  385. }
  386. }
  387.  
  388. // *****************************************
  389. // Name: TicTacToe
  390. //
  391. // Aufgabe: Soll das Spiel Tic Tac Toe mit
  392. // 3 Leveln spielbar machen
  393. // *****************************************
  394.  
  395. public static void main(String[] args) {
  396.  
  397. LevelAuswahl();
  398. Fall1();
  399. Fall2();
  400.  
  401. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!