4 Gewinnt in der Programmiersprache C

  • 4 Gewinnt in der Programmiersprache C

    Hallo Leute,

    brauche tips für 4 Gewinnt Programmieren, Habe schon die Tabelle für 4 Gewinnt fertig, wie geht ich jetzt vor??? Hat einer ein Quell code da??? Aber nicht wie der unter easy code????

    Die Tabelle für 4 Gewinnt Quell code


    #include <stdio.h>
    #include <stdlib.h>
    #ifdef __unix__
    #define clrscr() printf("\x1B[2J")
    #elif __BORLANDC__ && __MSDOS__
    #include <conio.h>
    #elif __WIN32__ || _MSC_VER
    #define clrscr() system("cls")
    #else
    #define clrscr() printf("clrscr() – Fehler!!\n")
    #endif
    #define X 'X'
    #define O 'O'
    #define LEER ' '
    #define GAME_OVER 0
    #define A_WINNER 1
    #define CONTINUE 2
    /* Inhalt des 7 x 6 grossen Felds */
    char TicTacToe[7][6] = { {' ',' ',' ',' ',' ',' ',' '},
    {' ',' ',' ',' ',' ',' ',' '},
    {' ',' ',' ',' ',' ',' ',' '},
    {' ',' ',' ',' ',' ',' ',' '},
    {' ',' ',' ',' ',' ',' ',' '},
    {' ',' ',' ',' ',' ',' ',' '} };
    /* Spieler1 hat das Zeichen 'X' */
    char Spieler1 = X;
    /* Spieler2 hat das Zeichen 'O' */
    char Spieler2 = O;
    /* Anzahl der Felder, die besetzt werden können */
    unsigned int felder = 42;
    /* Funktionsprototypen */
    void print_spielfeld(void);
    char neuer_zug(char);
    int if_win(void);
    /* Gibt den aktuellen Zustand des Spielfelds aus */
    void print_spielfeld(void) {
    int i;
    clrscr();

    printf("\n\n\n\t\tVIER GEWINNT\n\n\n");
    printf(" 1 2 3 4 5 6 7 \n +---+---+---+---+---+---+---+\n");
    for(i = 0; i < 6; i++) {
    printf(" %d | ",i+1);
    printf("%c",[0]);
    printf(" | ");
    printf("%c",[i][1]);
    printf(" | ");
    printf("%c",[i][2]);
    printf(" | ");
    printf("%c",[i][3]);
    printf(" | ");
    printf("%c",[i][4]);
    printf(" | ");
    printf("%c",[i][5]);
    printf(" | ");
    printf("%c",[i][6]);
    printf(" | ");
    printf("%c",[i][7]);
    printf(" \n");

    if(i != 2) {
    printf(" +---+---+---+---+---+---+---+\n");
    }
    else {
    printf(" +---+---+---+---+---+---+---+\n");
    }
    }
    }
  • Aufgabe
    Entwickeln Sie ein Programm, das „Vier gewinnt“ spielen kann. Falls Sie das Spiel nicht
    kennen, finden Sie eine Beschreibung unter de.wikipedia.org/wiki/Vier_gewinnt.
    Das Programm soll:

    1. Ein interaktives Spiel ermöglichen und dabei einen der beiden Spieler ersetzen.

    2. Immer nur regelkonforme Züge machen und annehmen (was nicht schwer ist, da es
    immer nur max. 7 mögliche Züge gibt).

    3. Das Spielfeld mit dem aktuellen Spielzustand darstellen können (einfache wiederholte
    Ausgabe des Feldes in Farbe ASCII-Grafik genügt!).

    4. Erkennen, wenn einer der Spieler verloren hat, d.h. vier Steine horizontal, vertikal oder
    diagonal in einer Reihe liegen.

    5. Eine Gewinnstrategie haben.

    Kommentieren und formatieren Sie das Programm und benennen Sie die Variablen und
    Funktionen gemäß der in der Vorlesung genannten Richtlinien.
  • hier ist der Code, was ich so gemacht habe, wie mache ich jetzt die KI???? würde auch gerne die schrieft farbig machen????



    Quellcode

    1. /* tictactoe.c in 4 Gewinnt umwandeln */
    2. #include <stdio.h>
    3. #include <stdlib.h>
    4. #ifdef __unix__
    5. #define clrscr() printf("\x1B[2J")
    6. #elif __BORLANDC__ && __MSDOS__
    7. #include <conio.h>
    8. #elif __WIN32__ || _MSC_VER
    9. #define clrscr() system("cls")
    10. #else
    11. #define clrscr() printf("clrscr() – Fehler!!\n")
    12. #endif
    13. #define X 'X'
    14. #define O 'O'
    15. #define LEER ' '
    16. #define GAME_OVER 0
    17. #define A_WINNER 1
    18. #define CONTINUE 2
    19. /* Inhalt des 7 x 6 grossen Felds */
    20. char TicTacToe[7][6] = { {' ',' ',' ',' ',' ',' ',' '},
    21. {' ',' ',' ',' ',' ',' ',' '},
    22. {' ',' ',' ',' ',' ',' ',' '},
    23. {' ',' ',' ',' ',' ',' ',' '},
    24. {' ',' ',' ',' ',' ',' ',' '},
    25. {' ',' ',' ',' ',' ',' ',' '} };
    26. /* Spieler1 hat das Zeichen 'X' */
    27. char Spieler1 = X;
    28. /* Spieler2 hat das Zeichen 'O' */
    29. char Spieler2 = O;
    30. /* Anzahl der Felder, die besetzt werden können */
    31. unsigned int felder = 42;
    32. /* Funktionsprototypen */
    33. void print_spielfeld(void);
    34. char neuer_zug(char);
    35. int if_win(void);
    36. /* Gibt den aktuellen Zustand des Spielfelds aus */
    37. void print_spielfeld(void) {
    38. int i;
    39. clrscr();
    40. printf("\n\n\n\t\tVIER GEWINNT\n\n\n");
    41. printf(" 1 2 3 4 5 6 7 \n +---+---+---+---+---+---+---+\n");
    42. for(i = 0; i < 6; i++) {
    43. printf(" %d | ",i+1);
    44. printf("%c",TicTacToe[i][0]);
    45. printf(" | ");
    46. printf("%c",TicTacToe[i][1]);
    47. printf(" | ");
    48. printf("%c",TicTacToe[i][2]);
    49. printf(" | ");
    50. printf("%c",TicTacToe[i][3]);
    51. printf(" | ");
    52. printf("%c",TicTacToe[i][4]);
    53. printf(" | ");
    54. printf("%c",TicTacToe[i][5]);
    55. printf(" | ");
    56. printf("%c",TicTacToe[i][6]);
    57. printf(" | ");
    58. printf("%c",TicTacToe[i][7]);
    59. printf(" \n");
    60. if(i != 2) {
    61. printf(" +---+---+---+---+---+---+---+\n");
    62. }
    63. else {
    64. printf(" +---+---+---+---+---+---+---+\n");
    65. }
    66. }
    67. }
    68. /* Führt einen neuen Zug aus.
    69. * char ch: Zeichen des Spielers, der an der Reihe ist, 'X'
    70. * oder 'O'
    71. * Rückgabewert: Zeichen des Spielers, der eben an der Reihe war
    72. * falls ein Feld besetzt ist, wird der Rückgabewert vertauscht,
    73. * damit der aktuelle Spieler nochmals seinen Zug machen kann.
    74. * Hat ein Spieler gewonnen, gibt die Funktion die
    75. * symb. Konstante GAME_OVER zurück
    76. */
    77. char neuer_zug(char ch) {
    78. unsigned int row, colum;
    79. printf("\n\n\tSpieler \"%c\" ist an der Reihe\n\n",ch);
    80. printf("\n\tZeile (1–7): ");
    81. scanf("%d",&row);
    82. printf("\n\tSpalte (1-6): ");
    83. scanf("%d",&colum);
    84. if(TicTacToe[row-1][colum-1] == LEER) {
    85. /* Zeichen in das mehrdim. Array */
    86. TicTacToe[row-1][colum-1] = ch;
    87. print_spielfeld();
    88. /* Haben wir schon einen Gewinner? */
    89. if(if_win() == A_WINNER)
    90. return GAME_OVER;
    91. }
    92. else { /* Ein bereits besetztes Feld */
    93. print_spielfeld();
    94. printf("\n!!! Feld ist bereits gesetzt !!!\n");
    95. return (ch == X) ?O :X;
    96. }
    97. /* Sind bereits alle Felder besetzt? */
    98. if(--felder > 0)
    99. return ch;
    100. else {
    101. printf("\nAlle Felder sind besetzt – Unentschieden\n");
    102. return GAME_OVER;
    103. }
    104. }
    105. /* Auswertung aller Möglichkeiten, um einen Gewinner zu ermitteln
    106. * Rückgabewert: symb. Konstante A_WINNER falls ein Gewinner
    107. * ermittelt wurde oder die symb. Konstante CONTINUE zum
    108. * Weiterspielen.
    109. */
    110. int if_win(void) {
    111. /* Zuerst Spieler1 'X' */
    112. if(TicTacToe[0][0] == Spieler1 &&
    113. TicTacToe[0][1] == Spieler1 &&
    114. TicTacToe[0][2] == Spieler1 ||
    115. TicTacToe[1][0] == Spieler1 &&
    116. TicTacToe[1][1] == Spieler1 &&
    117. TicTacToe[1][2] == Spieler1 ||
    118. TicTacToe[2][0] == Spieler1 &&
    119. TicTacToe[2][1] == Spieler1 &&
    120. TicTacToe[2][2] == Spieler1 ||
    121. TicTacToe[0][0] == Spieler1 &&
    122. TicTacToe[1][0] == Spieler1 &&
    123. TicTacToe[2][0] == Spieler1 ||
    124. TicTacToe[0][1] == Spieler1 &&
    125. TicTacToe[1][1] == Spieler1 &&
    126. TicTacToe[2][1] == Spieler1 ||
    127. TicTacToe[0][2] == Spieler1 &&
    128. TicTacToe[1][2] == Spieler1 &&
    129. TicTacToe[2][2] == Spieler1 ||
    130. TicTacToe[0][0] == Spieler1 &&
    131. TicTacToe[1][1] == Spieler1 &&
    132. TicTacToe[2][2] == Spieler1 ||
    133. TicTacToe[0][2] == Spieler1 &&
    134. TicTacToe[1][1] == Spieler1 &&
    135. TicTacToe[2][0] == Spieler1) {
    136. printf("Spieler1 hat gewonnen\n");
    137. return A_WINNER;
    138. }
    139. /* Jetzt Spieler2 'O' */
    140. else if( TicTacToe[0][0] == Spieler2 &&
    141. TicTacToe[0][1] == Spieler2 &&
    142. TicTacToe[0][2] == Spieler2 ||
    143. TicTacToe[1][0] == Spieler2 &&
    144. TicTacToe[1][1] == Spieler2 &&
    145. TicTacToe[1][2] == Spieler2 ||
    146. TicTacToe[2][0] == Spieler2 &&
    147. TicTacToe[2][1] == Spieler2 &&
    148. TicTacToe[2][2] == Spieler2 ||
    149. TicTacToe[0][0] == Spieler2 &&
    150. TicTacToe[1][0] == Spieler2 &&
    151. TicTacToe[2][0] == Spieler2 ||
    152. TicTacToe[0][1] == Spieler2 &&
    153. TicTacToe[1][1] == Spieler2 &&
    154. TicTacToe[2][1] == Spieler2 ||
    155. TicTacToe[0][2] == Spieler2 &&
    156. TicTacToe[1][2] == Spieler2 &&
    157. TicTacToe[2][2] == Spieler2 ||
    158. TicTacToe[0][0] == Spieler2 &&
    159. TicTacToe[1][1] == Spieler2 &&
    160. TicTacToe[2][2] == Spieler2 ||
    161. TicTacToe[0][2] == Spieler2 &&
    162. TicTacToe[1][1] == Spieler2 &&
    163. TicTacToe[2][0] == Spieler2) {
    164. printf("Spieler2 hat gewonnen\n");
    165. return A_WINNER;
    166. }
    167. return CONTINUE;
    168. }
    169. int main(void) {
    170. char check = X;
    171. /* Leeres Spielfeld ausgeben */
    172. print_spielfeld();
    173. do { /* War Spieler mit dem Zeichen 'X' gerade dran ... */
    174. /* ... dann ist jetzt Spieler mit dem Zeichen 'O' dran */
    175. if(check==X) {
    176. check=neuer_zug(O);
    177. }
    178. else { /* ... ansonsten der Spieler mit dem Zeichen 'X' */
    179. check=neuer_zug(X);
    180. }
    181. } while( check != GAME_OVER );
    182. return EXIT_SUCCESS;
    183. }
    Alles anzeigen

    [/i][/i][/i][/i][/i][/i][/i][/i]
  • Das mit den #defines, wie in Zeile 13 bis 18, war vor Jahren mal in Mode.
    In aktuellen Sourcen sollte es in dieser Form eigentlich nicht notwendig sein.

    Bloodshed DevC hat ja den MinGW als Compiler, der ja aus dem Linux kam.
    Deswegen die compilerspezifischen #defines, Zeile 4 bis 12, für die verschiedenen Compiler.
    Wahrscheinlich stammt der Code aus der Win95 oder spätestens Win98-Zeit.

    die

    Quellcode

    1. void print_spielfeld(void)
    2. {
    3. }

    solltest du mindestens 1/3 kürzer schreiben da du einige Redundanzen drin hast
    und was soll das if gegen Ende?

    Die Auswertung musst du ja eh noch anpassen.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von bcc-fan ()

  • Zitat 1. Beitrag Bits: Aber nicht wie der unter easy code????
    Troll oder drunken: Hat jemand von euch ein Quellcode von 4 Gewinnt???????????

    Bits
    bist du da eingeschrieben:
    bits-iserlohn.de/
    dann solltest du vielleicht einen Ghostwriter beschäftigen ;)

    Zum Quelltext:

    c-plusplus.de/forum/viewtopic-var-t-is-231779.html
    c-plusplus.de/forum/viewtopic-var-t-is-232317.html

    Meine Kommentare waren dazu gedacht, das du den Quelltext den
    du hier bisher gepostet hast anpasst. Als Basis waren TicTacToe
    doch brauchbar.

    Du musst auch ein wenig selbst investieren, Zeit und Gehirnzellen.