4 gewinnt

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

  • 4 gewinnt

    hi bin student an der uni darmstadt und wir haben gerade mit java angefangen
    nun habe ich folgende hausübung abzugeben das spiel 4 gewinnt

    code:
    in diesem code soll noch nun putInColumn erstellen sowie prüfen ob hasfor vertically und so weiter zutrifft. ich habe keinen plan welcher code da rein muss , hilfe erwünscht :)

    Quellcode

    1. public class ConnectFour extends ConsoleProgram /* DialogProgram */{
    2. // state variables of this object
    3. int width = 7;
    4. int height = 6;
    5. char[][] board = new char[width][height];
    7. /**
    8. * Main loop of the program. Let players take turns entering moves until one
    9. * player wins or the board is full, in which case the game is a draw.
    10. */
    11. public void run() {
    12. int player = 1;
    13. println("---- 4 GEWINNT -----");
    15. // no winner yet.
    16. int winner = 0;
    18. while (winner == 0 && !isFull()) {
    19. // print the current board
    20. printBoard();
    21. // prompt the current player to enter a move
    22. promptPlayerMessage(player);
    23. // read the move from the player
    24. int x = readInt();
    26. // terminate when -1 is entered
    27. if (x == -1)
    28. System.exit(0);
    30. // players count from 1, Java from 0
    31. x--;
    33. // is input in correct range?
    34. if (x >= 0 && x < width) {
    35. // valid move, perform it
    36. int y = putInColumn(x, player);
    37. if (y == -1)
    38. // output row is full message
    39. rowFullMessage(x);
    40. else if (hasWon(x, y))
    41. winner = player;
    42. else
    43. // next player
    44. player = 3 - player;
    45. } else
    46. // invalid move
    47. errorMessage();
    49. }
    50. // game has ended, either we have a winner or a draw
    51. if (winner == 0)
    53. drawMessage();
    54. else
    55. winMessage(winner);
    56. }
    58. /**
    59. * Initializes the Connect Four Game
    60. *
    61. */
    62. public ConnectFour() {
    63. init();
    64. }
    66. /**
    67. * Returns the char that represents a player (i.e. x or o)
    68. *
    69. * @param playerNo
    70. * number of the player, i.e. 1 or 2
    71. * @return the char for the player
    72. */
    73. public char getPlayerChar(int playerNo) {
    74. char[] playerChars = { 'x', 'o' };
    75. return playerChars[playerNo - 1];
    76. }
    78. /**
    79. * Prints the current board For example:
    80. * |
    81. * |
    82. * |
    83. * | o x
    84. * | o x x
    85. * |o x x o x
    86. * -------------
    87. * 1 2 3 4 5 6 7
    88. *
    89. */
    90. public void printBoard() {
    91. StringBuffer sb = new StringBuffer();
    92. for (int i = 0; i < height; i++) {
    93. // start of a line
    94. sb.append("|");
    95. for (int j = 0; j < width; j++) {
    96. sb.append(board[j][i]).append(' ');
    97. }
    98. // end of a line
    99. sb.append('\n');
    100. }
    101. sb.append(" -------------\n");
    102. sb.append(" 1 2 3 4 5 6 7");
    103. println(sb.toString());
    104. }
    106. /**
    107. * Checks whether the game is won and who won the game
    108. *
    109. * @return the number of the winner (i.e. 1 or 2) or 0 if no one has yet won
    110. * the game
    111. */
    112. public boolean hasWon(int x, int y) {
    113. return (hasFourHorizontally(x, y) || hasFourVertically(x, y)
    114. || hasFourDiagonally(x, y));
    115. }
    117. /**
    118. * Checks whether another game piece can be added
    119. *
    120. * @return true if the board is full
    121. */
    122. public boolean isFull() {
    123. for (int x = 0; x < width; x++)
    124. if (board[x][0] == '_')
    125. return false;
    126. return true;
    127. }
    131. /**
    132. * Test whether there are four gaming pieces with the given char above each
    133. * other. Only checking column x needed as this is the only column a vertical
    134. * four-in-a-row could have been created in this turn.
    135. *
    136. * @param x
    137. * column of the last added piece
    138. * @param y
    139. * row of the last added piece
    140. * @return whether their are four gaming pieces above each other
    141. */
    142. public boolean hasFourVertically(int x, int y) {
    143. //TODO implement
    144. return false;
    145. }
    147. /**
    148. * Test whether there are four gaming pieces with the given char next to each
    149. * other. Only checking column x needed as this is the only column a horizontal
    150. * four-in-a-row could have been created in this turn.
    151. *
    152. * @param x
    153. * column of the last added piece
    154. * @param y
    155. * row of the last added piece
    156. * @return whether their are four gaming pieces next to each other
    157. */
    158. public boolean hasFourHorizontally(int x, int y) {
    159. //TODO implement
    160. return false;
    161. }
    164. /**
    165. * Test whether there are 4 gaming pieces next to each other on a diagonal.
    166. * Only checking column x needed as this is the only column a horizontal
    167. * four-in-a-row could have been created in this turn.
    168. *
    169. * @param x
    170. * column of the last added piece
    171. * @param y
    172. * row of the last added piece
    173. * @return whether there are 4 gaming pieces next to each other on a diagonal
    174. */
    175. public boolean hasFourDiagonally(int x, int y) {
    176. //TODO implement
    177. return false;
    178. }
    181. /**
    182. * Initialize the board with blanks
    183. *
    184. */
    185. public void init() {
    186. //TODO implement
    187. board[6][5] = '_';
    189. }
    192. /* messages */
    193. private void promptPlayerMessage(int p) {
    194. //TODO implement
    195. println("Spielerszug "+p);
    196. }
    198. private void rowFullMessage(int x) {
    199. //TODO implement
    200. println("Die Reihe ist voll");
    201. }
    203. private void winMessage(int p) {
    204. //TODO implement
    205. println("Es gewinnt Spieler" +p);
    206. }
    208. private void drawMessage() {
    209. //TODO implement
    210. println("unentschieden keiner gewinnt ihr Affen");
    211. }
    213. private void errorMessage() {
    214. //TODO implement
    215. showErrorMessage("Eingabe falsch etwas stimmt nicht!!!");
    217. }
    219. /**
    220. * Put a gaming piece on top of the gaming pieces in the given column by the
    221. */
    222. public int putInColumn(int column, int playerNo) {
    223. //TODO put piece of player in column
    225. return -1;
    226. }
    229. /**
    230. * Main method. This is automatically called by the environment when your
    231. * program starts.
    232. *
    233. * @param args
    234. */
    235. public static void main(String[] args) {
    236. new ConnectFour().run();
    237. }
    238. }
    Alles anzeigen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von danny_k ()

  • Der JavaDOC-Kommentar für putInColumn() scheint nicht vollständig zu sein. Entweder du hast nicht alles hier ein gepostet, oder es wurde etwas vergessen. Dann solltest du den Aufgabensteller einmal nach dem vollständigen Java-DOC Kommentar fragen. Die drei hasFour-Methoden sind so deutlich beschrieben, dass du sie auch allein lösen kannst.

    Edit:
    ich habe mit das Programm mal näher angeschaut und weiß nun was du in putInColumn tun musst. Einen neuen Spielstein des übergebenen Spielers in der übergebenen Spalte platzieren. Wenn die Spalte schon voll ist, dann gibst du -1 zurück, ansonsten 0.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Hafner ()

  • danny_k schrieb:

    Sorry Wie funktioniert das mit den tags

    Du hast unter deinem Edit Feld, wenn du einen Beitrag erstellst, eine Reihen bunter Symbole, welche zum Reiter Syntax gehören. da gibt es unter anderem Bash, D und C++, C#, etc. Da drauf klicken und dann zwischen syntax="***"] und [/syntax deinen code einfügen.
    Open Source --> Programmieren aus Leidenschaft :!:

    Ich stehe weder für privaten Support per PM noch über einen IM zur Verfügung. Danke.

  • RE: hi

    danny_k schrieb:


    leider bin ich noch ziemicher anfänger und habe noch nicht so wirklich plan was ich für die hasFour funktion genau implementieren soll bsp. wäre sehr gut

    Aber was über den Funktionen steht hast du dir durchgelesen, oder? Ich weiß nicht was ich da noch mehr dazu sagen soll. Die Typen int und boolean sind dir bekannt oder? Wo liegt den dein Problem konkret? Fällt dir keine algorithmische Lösung ein? Bezüglich der Syntax hast du ja in dem von dir geposteten Code selbst genug Beispiele.

    Die fertige Lösung wirst du von mir hier nicht pressentiert bekommen. Bei konkteten Problemen helfe ich dagegen gern.

  • hi,

    ja es geht um die algorythmsche lösung. int arrays char ok, aber wie prüfe ich ob nun eine diagonale oder verticale auf irgendeiner position besteht . es fällt mir etwas schwer da die die genaue lösung für die funktionen zu verstehen.

    wie prüfe ich also ob 4 steine übereinstimmen auf irgendeinem platz in reihe. for schleife ? while? eventuell . spielernummer dazu?

  • Also, du hast ja bei z.B. hasFourHorizontally die 2 Koordinaten. Mittels x und y und dem board Array kannst du ja raus finden was für ein Stein das ist (also von welchem Spieler), denn der Stein ist ja schon gesetzt. Wenn du also den char aus dem Board ausgelesen hast, musst du also nur noch prüfen ob auf der selben Reihe vier gleiche chars sind.
    Was in deinem Array Reihen und was Spalten sind, solltest du eigentlich in der printBoard()-Methode am besten nachvollziehen können. Allerdings scheint die Methode nicht völlig richtig zu sein. Hast du die implementiert oder wurde die so vorgegeben?
    Das

    Quellcode

    1. sb.append(board[j]).append(' ');

    sieht nicht ganz richtig aus. Ich würde eher sowas

    Quellcode

    1. sb.append(board[j][i]).append(' ');

    erwarten.

    Edit:
    Da das board so initialisiert wird:

    Quellcode

    1. char[][] board = new char[width][height];

    sollte klar sein was Zeilen und was Spalten sind.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Hafner ()

  • wir studenten haben eine package bekommen das bsp. println beeinhaltet

    es is alles vorgegebn bis auf

    System.out.println Ausgabe die durch das println hier angeben sind. Sprich die meldung gewinner unentschieden etc. das kommt von mir

    die init prozedur ebenfalls von mir der rest ist vorgegeben

    sb.append ist mir auch nicht so klar was das macht append fügt doch mehrere Felder zusammen oder?

    so mein code für FourHorizontally der kann nicht stimmen denk ich aber bewge ich mich auf die richtige lösung zu??

    Quellcode

    1. public boolean hasFourHorizontally(int x, int y) {
    2. // TODO implement
    3. for (x = 0; x < 4; x++)
    4. if (board[x][y] == 'x')
    5. return true;
    6. return false;


    ok wie lese ich mit char den letzt gelegenen stein aus? erstmal das :-<
    ja das mit dem stringbuffer ist von der uni vorgegeben

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von danny_k ()

  • Ja, append hängt nur etwas am ende des StringBuffers an. Warum man überhaupt StringBuffer und nicht String verwendet und dann nicht einfach den plus-Operator ist mir schleierhaft. Das ist aber nicht das, was ich meinte. Ich meinte die Adressierung der Zelle im Array, die meiner Meinung nach unvollständig ist.

    Was deinen Code-Ausschnitt angeht:
    Du weißt wie eine for-Scheife funktioniert? "x = 0;" überschreibst erst einmal die dir übergebene x-Variable mit 0 (damit verlierst du schon mal die Spalte des aktuell gelegten Steins). Dann gehst du für 0, 1, 2, 3, 4 (warum für 5 Werte?) die for-Scheife durch. Jetzt prüfst du ob ob die Zelle den char 'x' enthält. Warum x? Es könnte ja auch der andere Spieler gewesen sein. Lese doch erst mal den char des zuletzt gelegten Steins aus dem board aus, damit du weist wer zuletzt dran war. Zudem gibst du 0 als Wert für die Zeile des boards an. Wie kommst du auf 0? Ich denke es wäre hier sinnvoll die Zeilennummer des zuletzt gelegten Steines zu verwenden, also y. Nun wird es noch kurioser, wenn "board[x][0] == 'x'" wirklich wahr sein sollte, dann prüfst du noch "board[x][0] == 'o'". Beides zusammen kann gar nicht wahr sein. Deine Methode gibst also immer false zurück.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Hafner ()

  • board[x][0] == y ???
    Das compiliert doch nicht oder? Warum sollte der char von board[x][0] der selbe sein wie die int-y-Koordinate des zuletzt gelegten Steins? Bist du dir bewusst, dass bei einem return die Methode verlassen wird, völlig egal ob du noch in Schleifen bist oder nicht?

    Also, ich formuliere es mal in Worten:
    1. Den char des zuletzt gelegten Steines mit Hilfe der x und y Koordinaten aus dem board-Array holen.
    2. Zählen, wie viele Steine nacheinander (!) links und rechts von dem aktuellen Stein den selben char im board-Array haben.
    3. Wenn die Summe der gezählten Steine links, der gezählten Steine rechts größer/gleich als 3 ist, dann gibst du true zurück ansonsten false (3 deshalb, da der gerade gelegte Stein ja auch einer ist).

  • hi,

    So leut ich hab das jetzt so gelöst

    Quellcode

    1. import acm.program.ConsoleProgram;
    2. import acm.program.DialogProgram;
    4. public class ConnectFour extends ConsoleProgram /* DialogProgram */{
    5. // state variables of this object
    6. int width = 7;
    7. int height = 6;
    8. char[][] board = new char[width][height];
    10. /**
    11. * Main loop of the program. Let players take turns entering moves until one
    12. * player wins or the board is full, in which case the game is a draw.
    13. */
    14. public void run() {
    15. int player = 1;
    16. println("---- 4 GEWINNT -----");
    18. // no winner yet.
    19. int winner = 0;
    21. while (winner == 0 && !isFull()) {
    22. // print the current board
    23. printBoard();
    24. // prompt the current player to enter a move
    25. promptPlayerMessage(player);
    26. // read the move from the player
    27. int x = readInt();
    29. // terminate when -1 is entered
    30. if (x == -1)
    31. System.exit(0);
    33. // players count from 1, Java from 0
    34. x--;
    36. // is input in correct range?
    37. if (x >= 0 && x < width) {
    38. // valid move, perform it
    39. int y = putInColumn(x, player);
    40. if (y == -1)
    41. // output row is full message
    42. rowFullMessage(x);
    43. else if (hasWon(x, y))
    44. winner = player;
    45. else
    46. // next player
    47. player = 3 - player;
    48. } else
    49. // invalid move
    50. errorMessage();
    52. }
    53. // game has ended, either we have a winner or a draw
    54. if (winner == 0)
    56. drawMessage();
    57. else
    58. winMessage(winner);
    59. }
    61. /**
    62. * Initializes the Connect Four Game
    63. *
    64. */
    65. public ConnectFour() {
    66. init();
    67. }
    69. /**
    70. * Returns the char that represents a player (i.e. x or o)
    71. *
    72. * @param playerNo
    73. * number of the player, i.e. 1 or 2
    74. * @return the char for the player
    75. */
    76. public char getPlayerChar(int playerNo) {
    77. char[] playerChars = { 'x', 'o' };
    78. return playerChars[playerNo - 1];
    79. }
    81. /**
    82. * Prints the current board For example: | | | |o x |o x x |o x x o x
    83. * ------------- 1 2 3 4 5 6 7
    84. *
    85. */
    86. public void printBoard() {
    87. StringBuffer sb = new StringBuffer();
    88. for (int i = 0; i < height; i++) {
    89. // start of a line
    90. sb.append("|");
    91. for (int j = 0; j < width; j++) {
    92. sb.append(board[j][i]).append(' ');
    93. }
    94. // end of a line
    95. sb.append('\n');
    96. }
    97. sb.append(" -------------\n");
    98. sb.append(" 1 2 3 4 5 6 7");
    99. println(sb.toString());
    100. }
    102. /**
    103. * Checks whether the game is won and who won the game
    104. *
    105. * @return the number of the winner (i.e. 1 or 2) or 0 if no one has yet won
    106. * the game
    107. */
    108. public boolean hasWon(int x, int y) {
    109. return (hasFourHorizontally(x, y) || hasFourVertically(x, y) || hasFourDiagonally (x, y));}
    111. /**
    112. * Checks whether another game piece can be added
    113. *
    114. * @return true if the board is full
    115. */
    116. public boolean isFull() {
    117. for (int x = 0; x < width; x++)
    118. if (board[x][0] == '_')
    119. return false;
    120. return true;
    121. }
    123. /**
    124. * Test whether there are four gaming pieces with the given char above each
    125. * other. Only checking column x needed as this is the only column a
    126. * vertical four-in-a-row could have been created in this turn.
    127. *
    128. * @param x
    129. * column of the last added piece
    130. * @param y
    131. * row of the last added piece
    132. * @return whether their are four gaming pieces above each other
    133. */
    134. public boolean hasFourVertically(int x, int y) {
    135. int win = 0;
    136. for (int i = 0; i < height; i++) {
    137. if (board[x][i] == board[x][y])
    138. win++;
    139. else
    140. win = 0;
    141. if (win == 4)
    142. return true;
    143. }
    144. return false;
    145. }
    147. /**
    148. * Test whether there are four gaming pieces with the given char next to
    149. * each other. Only checking column x needed as this is the only column a
    150. * horizontal four-in-a-row could have been created in this turn.
    151. *
    152. * @param x
    153. * column of the last added piece
    154. * @param y
    155. * row of the last added piece
    156. * @return whether their are four gaming pieces next to each other
    157. */
    158. public boolean hasFourHorizontally(int x, int y) {
    159. // TODO implement
    160. // int playersymbol = board [x][y];
    161. int win = 0;
    162. for (int i = 0; i < width; i++) {
    163. if (board[i][y] == board[x][y])
    164. win++;
    165. else
    166. win = 0;
    167. if (win == 4)
    168. return true;
    169. }
    171. return false;
    172. }
    174. /**
    175. * Test whether there are 4 gaming pieces next to each other on a diagonal.
    176. * Only checking column x needed as this is the only column a horizontal
    177. * four-in-a-row could have been created in this turn.
    178. *
    179. * @param i
    180. * column of the last added piece
    181. * @param j
    182. * row of the last added piece
    183. * @return whether there are 4 gaming pieces next to each other on a
    184. * diagonal
    185. */
    188. public boolean hasFourDiagonally(int x, int y) {
    189. int playerSymbol = board[x][y];
    190. int i = x;
    191. int j = y;
    192. int count = 0;
    194. while ((i > 0) && (j > 0)) {
    195. i--;
    196. j--;
    197. }
    199. while ((i <= 6) && (j <= 5)) {
    200. if (board[i][j] == playerSymbol)
    201. count++;
    202. else
    203. count = 0;
    204. i++;
    205. j++;
    206. }
    207. if (count == 4)
    208. return true;
    209. return false;
    210. }
    212. /**
    213. * Initialize the board with blanks
    214. *
    215. */
    216. public void init() {
    217. for (int i = 0; i < width; i++) { // i = höhe
    218. for (int j = 0; j < height; j++) { // j = breite
    219. board[i][j] = '_';
    220. }
    221. }
    222. }
    224. /* messages */
    225. private void promptPlayerMessage(int p) {
    226. // TODO implement
    227. println("Spielerszug " + p);
    228. }
    230. private void rowFullMessage(int x) {
    231. // TODO implement
    232. println("Die Reihe ist voll");
    233. }
    235. private void winMessage(int p) {
    236. printBoard();
    237. // TODO implement
    238. println("Es gewinnt Spieler " + p);
    239. }
    241. private void drawMessage() {
    242. // TODO implement
    243. println("unentschieden keiner gewinnt ihr Affen");
    244. }
    246. private void errorMessage() {
    247. // TODO implement
    248. showErrorMessage("Eingabe falsch etwas stimmt nicht!!!");
    250. }
    252. /**
    253. * Put a gaming piece on top of the gaming pieces in the given column by the
    254. */
    255. public int putInColumn(int column, int playerNo) {
    256. // Zählt die höhe herunter bis auf 0
    257. for (int y = height - 1; y >= 0; y--) {
    258. // Wenn array '_' das entspricht
    259. if (board[column][y] == '_') {
    260. board[column][y] = getPlayerChar(playerNo);
    261. return y;
    262. }
    263. }
    264. return -1;
    265. }
    267. /**
    268. * Main method. This is automatically called by the environment when your
    269. * program starts.
    270. *
    271. * @param args
    272. */
    273. public static void main(String[] args) {
    274. new ConnectFour().start();
    275. }
    276. }
    Alles anzeigen

  • und weiter 4 Gewinnt

    Hi Leute ich mal für dieses 4 Gewinnt eine prozedur geschrieben die 4 Vertikale also von links unten nach rechts oben einen sieg bringen soll.

    Geht aber nicht schaut euch bitte mal den code an und erklärt mir mal bitte wo der fehler liegt ich weiß es echt nicht. Danke

    Quellcode

    1. public boolean hasFourDiagonally(int x, int y) {
    2. int playerSymbol = board[x][y];
    3. int Spalte = x;
    4. int Hoehe = y;
    5. int count = 0;
    7. while ((Spalte >= 0) && (Hoehe <= 5)) {
    8. Spalte--;
    9. Hoehe++;
    11. }
    12. while ((Spalte < 6) && (Hoehe >= 5)) {
    13. if (board[Spalte][Hoehe] == playerSymbol)
    14. count++;
    15. else
    16. count = 0;
    17. Spalte++;
    18. Hoehe--;
    19. }
    20. if (count == 4)
    21. return true;
    22. return false;
    24. }
    Alles anzeigen


    Also meine Überlegung ist halt mit der ersten while Schleife setze ich den start der prozedur fest, dass wäre dann in dem graph links unten.
    dann soll er halt prüfen ob es vier diagonale überseisntimmen. wenn ja true also sieg wenn nicht dann halt false