JAVA: Vier gewinnt

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

  • JAVA: Vier gewinnt

    Quellcode

    1. /**
    2. * @author Torben Brodt
    3. * @version 1.1
    4. *
    5. * <p />Spiel: Vier gewinnt
    6. * <p />Funktioniert mit Java < 1.5
    7. *
    8. */
    9. public class A07_Vier_gewinnt {
    11. static String SPIELER; // der aktuelle Spielername -> für die Gewinner Ausgabe
    13. /**
    14. * @param args -> unbenutzt
    15. */
    16. public static void main(String[] args) {
    17. int columns, rows, zaehler = 0, eingabe;
    18. String player1, player2;
    19. char zeichen;
    20. char[][] spielfeld;
    22. //Abfragen des Spielernamens
    23. player1 = eingabeString("Name von SpielerIn A\t\t\t: ");
    25. do {
    26. player2 = eingabeString("Name von SpielerIn B\t\t\t: ");
    27. } while(player1.equals(player2)); //Frage erneut, wenn die Spielernamen gleich sind
    29. //Abfragen der Maße
    30. do {
    31. columns = eingabeInt("Breite des Spielfeldes (mindestens 4)\t: ");
    32. } while (columns < 4); //Frage erneut, wenn die Breite zu klein gewählt wurde
    34. do {
    35. rows = eingabeInt("Hoehe des Spielfeldes (mindestens 4)\t: ");
    36. } while (rows < 4); //Frage erneut, wenn die Höhe zu klein gewählt wurde
    38. spielfeld = new char[rows][columns];
    40. while (zaehler < columns*rows) {
    41. zeichen = (zaehler % 2 == 0) ? 'o' : '+';
    42. SPIELER = (zaehler % 2 == 0) ? player1 : player2;
    43. showSpielfeld(spielfeld);
    44. eingabe = eingabeInt("\n" + SPIELER + "(" + zeichen
    45. + ") ist am Zug. Bitte gib die Spalte ein: ");
    46. if (eingabe > columns || eingabe < 1)
    47. System.err.println("Feld existriert nicht.. Bitte versuch es nochmal!");
    48. else {
    49. zaehler++; // naechster Bitte
    50. setzeFeld(spielfeld, eingabe, zeichen);
    51. }
    52. }
    53. showSpielfeld(spielfeld);
    54. System.err.println("Unentschieden!");
    55. }
    57. /**
    58. * @param text -> Bildschirmausgabe
    59. * @return -> Tastatureingabe
    60. */
    61. static int eingabeInt(String text) {
    62. System.out.print(text);
    63. java.util.Scanner input = new java.util.Scanner(System.in);
    64. return input.nextInt();
    65. }
    67. /**
    68. * @param text -> Bildschirmausgabe
    69. * @return -> Tastatureingabe
    70. */
    71. static String eingabeString(String text) {
    72. System.out.print(text);
    73. java.util.Scanner input = new java.util.Scanner(System.in);
    74. return input.next();
    75. }
    77. /**
    78. * Spalte wird übergeben und das Feld wird gesetzt
    79. * @param spielfeld -> Das Spielfeld mit allen benötigten Daten
    80. * @param column -> eingegebene Spalte
    81. * @param zeichen -> jeder Spieler hat ein Zeichen (*) oder (+)
    82. */
    83. static void setzeFeld(char[][] spielfeld, int column, char zeichen) {
    84. column--; // Weil der gemeine Mensch denkt, der Zahlenbereich würde sich von 1 bis 4 erstrecken
    85. int pos2check;
    86. if (spielfeld[0][column] != '\0')
    87. System.err.println("Die Reihe ist voll.. Pech!");
    88. else
    89. for (int i = 0; i < spielfeld.length; i++) { //Iteriere durch die Zeilen
    90. if (i + 1 == spielfeld.length) {
    91. // Nach der letzten Zeile kommt nichts mehr..
    92. // also darf in das aktuelle Kästchen geschrieben werden, obwohl im
    93. // nächsten nichts steht
    94. pos2check = i;
    95. if (spielfeld[pos2check][column] == '\0') {
    96. spielfeld[i][column] = zeichen;
    97. if(IsGameOver(spielfeld, i, column, zeichen)) {// Hat jmd gewonnen?
    98. System.out.println("Spieler mit "+zeichen+"hat gewonnen");
    99. System.exit(0);
    100. }
    101. break;
    102. }
    104. } else {
    105. //Überprüfe immer das folgende Feld
    106. pos2check = i+1;
    107. if (spielfeld[pos2check][column] != '\0') {
    108. spielfeld[i][column] = zeichen;
    109. if(IsGameOver(spielfeld, i, column, zeichen)) {// Hat jmd gewonnen?
    110. System.out.println("Spieler mit "+zeichen+"hat gewonnen");
    111. System.exit(0);
    112. }
    113. break;
    114. }
    115. }
    116. }
    117. }
    119. /**
    120. * Sammelstelle für die Funktionen, die überprüfen ob jmd. gewonnen hat
    121. * @param spielfeld -> Das Spielfeld mit allen benötigten Daten
    122. * @param column -> die Spalte an der das Zeichen gesetzt wurde
    123. * @param row -> die Reihe an der das Zeichen gesetzt wurde
    124. * @param zeichen -> das Zeichen
    125. */
    126. static boolean IsGameOver(char[][] spielfeld, int column, int row, char zeichen) {
    127. boolean b1 = GameIsOver_row(spielfeld, column, row, zeichen);
    128. boolean b2 = GameIsOver_column(spielfeld, column, row, zeichen);
    129. boolean b3 = GameIsOver_straight1(spielfeld, column, row, zeichen);
    130. boolean b4 = GameIsOver_straight2(spielfeld, column, row, zeichen);
    132. return (b1||b2||b3||b4);
    133. }
    135. static boolean GameIsOver_row(char[][] spielfeld, int column, int row, char zeichen) {
    136. // nach links
    137. int go = row - 1; // mit dem Punkt links neber dem gesetzten beginne
    138. // ich
    139. int i = 1; // der gesetzte Punkt = 1 Treffer
    140. while (go >= 0) {
    141. if (spielfeld[column][go] != zeichen)
    142. break;
    143. go--;
    144. i++;
    145. }
    147. // nach rechts
    148. go = row + 1;
    149. while (go < spielfeld.length) {
    150. if (spielfeld[column][go] != zeichen)
    151. break;
    152. go++;
    153. i++;
    154. }
    156. return (i > 3);
    157. }
    159. static boolean GameIsOver_column(char[][] spielfeld, int column, int row, char zeichen) {
    160. // nach oben
    161. int go = column - 1;
    162. int i = 1;
    163. while (go >= 0) {
    164. if (spielfeld[go][row] != zeichen)
    165. break;
    166. go--;
    167. i++;
    168. }
    170. // nach unten
    171. go = column + 1;
    172. while (go < spielfeld.length) {
    173. if (spielfeld[go][row] != zeichen)
    174. break;
    175. go++;
    176. i++;
    177. }
    179. return (i > 3);
    180. }
    182. static boolean GameIsOver_straight1(char[][] spielfeld, int column, int row, char zeichen) {
    183. // nach links oben
    184. int go = row - 1;
    185. int go2 = column - 1;
    186. int i = 1;
    187. while (go >= 0 && go2 >= 0) {
    188. if (spielfeld[go2][go] != zeichen)
    189. break;
    190. go--;
    191. go2--;
    192. i++;
    193. }
    195. // nach rechts unten
    196. go = row + 1;
    197. go2 = column + 1;
    198. while (go < spielfeld[0].length && go2 < spielfeld.length) {
    199. if (spielfeld[go2][go] != zeichen)
    200. break;
    201. go++;
    202. go2++;
    203. i++;
    204. }
    206. return (i > 3);
    207. }
    209. static boolean GameIsOver_straight2(char[][] spielfeld, int column, int row, char zeichen) {
    210. // nach links unten
    211. int go = row - 1;
    212. int go2 = column + 1;
    213. int i = 1;
    214. while (go >= 0 && go2 < spielfeld.length) {
    215. if (spielfeld[go2][go] != zeichen)
    216. break;
    217. go--;
    218. go2++;
    219. i++;
    220. }
    222. // nach rechts oben
    223. go = row + 1;
    224. go2 = column - 1;
    225. while (go < spielfeld[0].length && go2 >= 0) {
    226. if (spielfeld[go2][go] != zeichen)
    227. break;
    228. go++;
    229. go2--;
    230. i++;
    231. }
    233. return (i > 3);
    234. }
    236. /**
    237. * Bricht das Programm ab und liefert den Gewinner
    238. * @param spielfeld -> Das Spielfeld mit allen benötigten Daten
    239. */
    240. static void spielFertig(char[][] spielfeld) {
    241. showSpielfeld(spielfeld);
    242. System.out.println(SPIELER + " hat gewonnen\n");
    243. System.exit(1);
    244. }
    246. /**
    247. * Zeigt das komplette Spielfeld auf dem Bildschirm
    248. * @param spielfeld -> Das Spielfeld mit allen benötigten Daten
    249. */
    250. static void showSpielfeld(char[][] spielfeld) {
    251. StringBuffer Geruest = new StringBuffer();
    252. StringBuffer row_start = new StringBuffer(" "); // erste Zeile 1 2 3 4
    253. StringBuffer row_divide = new StringBuffer("|"); // Trennzeile |-----|
    254. StringBuffer row_end = new StringBuffer("-"); // letzte Zeile -------
    256. if (spielfeld[0].length > 9) {
    257. for (int i = 1; i <= spielfeld[0].length; i++)
    258. row_start.append((i/10==0) ? " " : i/10).append(" ");
    259. row_start.append("\n ");
    260. }
    261. for (int i = 1; i <= spielfeld[0].length; i++) {
    262. row_start.append(i%10).append(" ");
    263. row_divide.append((i==spielfeld[0].length)? "-|" : "--");
    264. row_end.append("--");
    265. }
    266. System.out.println(row_start);
    267. System.out.println(row_divide);
    269. for (char[] arrZeile : spielfeld) { //iteriere durch alle Zeilen
    270. for (char arrSpalte : arrZeile) { //iteriere durch alle Spalten
    271. Geruest.append("|");
    272. Geruest.append((arrSpalte == '\0') ? ' ' : arrSpalte);
    273. }
    274. Geruest.append("|\n");
    275. }
    276. Geruest.append(row_end).append("\n");
    277. System.out.println(Geruest);
    278. }
    279. }
    Alles anzeigen

  • UML machen wir jetzt im dritten Semester auch.

    Das "Vier gewinnt" hab ich einfach runtergetippt. Das war noch zu Anfang des ersten Semesters.

    Wie ich dabei vorgegangen bin...
    * Als erstes kam die Ausgabefunktion, die ein leeres Array ausgeben musste
    * Dann das endlose Abwechseln zwischen den Spielern in der main()
    * Dann die setzeFeld()
    * am Anfang wurde das Zeichen einfach mal in [spalte][0] geschrieben
    * im nächsten Schritt war dann Ziel das Zeichen in der richtigen Höhe zu platzieren
    * am Ende noch die Gewinnabfragen ergänzen
    * fertig

    Das Herangehen an ein Problem hat jetzt allerdings nichts mit UML zu tun.