Vier gewinnt

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

  • Vier gewinnt

    Hallo zusammen,

    ich habe in unserem Infounterricht die Aufgabe ein 4 gewinnt Spiel in java zu programmieren.
    Habe es auch geschafft ein Programm zu schreiben, welches beim j-Creator unten ausgefürt wird.
    Allerdings habe ich jetzt den Anreitz ales im Browser ausführen zu können.

    Quellcode

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


    Hoffe das funktioniert ohne Probleme ^^

    Hoffe ihr könnt mir dabei helfen. Meine Überlegung war das ganze mit Applet zu verwirklichen.

    Danke schonmal im Voraus.

    MfG andrethiemann

  • Naja es geht nicht so sehr ohne Probleme das wir dir das hier binnen 5 Minuten machen können.
    Da musst du dich schon in die Applet-Thematik einarbeiten.

    So'ne Frage nebenbei: Warum sind alle Operationen bzw. Methoden bei dir static?
    [klugscheiss]
    Alles in die Mainmethode zu schreiben & alles als static zu deklarieren verfolgt nicht den OOP-Gedanken.
    [/klugscheiss]

    Bis denn :)