4 Gewinnt in C programmieren (Gewinnüberprüfung)
Hallo,
Ich bin gerade dabei für die Schule ein C Programm zu schreiben. Es soll wie 4 Gewinnt sein. Bis jetzt ist es eigentlich schon fertig, wenn man immer selber überprüft wer gewonnen hat. Der Lehrer meinte nur, es wäre ein "nettes Feature" wenn die gewinnüberprüfung auch automatisch geschehen würde. Kann mir da jemand helfen?
Ich erwarte keine direkte Lösung, sondern nur Tipps und Gedankenanstösse. Weil im Moment steh ich aufm Schlauch :D
Hier ist mal mein Code:
Ok, mein Code ist zu lang. Ich poste ihn in einer Antwort unter dem hier (:
Danke für Antworten.
MfG KilerAffe
4 Antworten
Ich würde jedes Mal wenn ein "Stein" gesetzt wurde, von diesem aus in alle Richtungen (horizontal, vertikal und beide Diagonalrichtungen) zählen, auf wieviele gleichfarbige Steine ich vom zuletzt gesetzten Stein aus komme.
Du brauchst nicht weiter als 3 Schritte in jede Richtung gehen. Leere oder fremdbesetzte Felder unterbrechen die Kette. Sobald du 4 oder mehr zusammen hast kannst du abbrechen.
Also z.B. horizontal: 2 links und 2 rechts -> 5 eigene Steine in einer Reihe -> gewonnen!
Das dürfte viel effizienter sein, als jedes mal das komplette Spielfeld abzugrasen!
Du könntest das Feld einmal komplett durchlaufen lassen und von jedem Element aus testen, ob die 3 von diesem Feld aus danebenliegenden Felder das gleiche Zeichen beinhalten.
ja, aber das horizontale geht jetzt schon. Jetzt ist nur noch das Vertikale und das Diagonale...
Naja, bring dem Programm einfach bei, wie du die Lösung selber prüfst. Das wird furchtbar viele Schleifen-Durchläufe beinhalten, aber das wird schon.
Was gibt es für Gewinn-Muster?
- horizontal 2x
- vertikal 2x
- diagonal 4x
Wie prüfst du?
Du musst jetzt in der einfachesten Lösung für jeden gesetzten Stein genau diese 3 Pattern prüfen. Wenn ein Stein auf 1,1 liegt, dann musst du für diagonal zB (2,2) - (3,3) und (4,4) prüfen. Für horizontal (1,2) - (1,3) und (1,4), sowie 1,0 - (1,-1) und (1,-2)
Damit solltest du nen Denkanstoß haben. ;) Happy coding!
Genau, das, jetzt für jedes Pattern in alle Richtung und fertig biste!^^ Sich kann man den Algorhytmus auch intellignter gestalten, sodass "unmöglcihe" Richtungen nicht mit geprüft werden, aber das wird die benötigte Zeit etwa um Null-komma-Josef verkürzen^^
Was? Aber ich bin doch jetzt noch nicht fertig. Horizontal geht es. Vertikal hab ich noch nicht probiert. Aber diagonal geht es immer noch nicht. o.O
Versteh ich jetzt was nicht mehr :D
EDIT: Ok, vertikal gehts auch nicht..
Aber dann muss ich ja jetzt ne 'else if' Schleife machen.
Und in der dann sagen
WENN von der jetztigen Position aus (Spielfeld[i][j]) unterhalb (i+1) nochmal ein A ist (SpielerA)
DANN dasselbe wiederholen bis er es 4 mal gemacht hat oder?
ABER, wie mache ich in der 'else if' klammer dass er i+1 machen soll? Dankeeee (:
Das geht ja nicht so: else if(i+1.......)
Jetzt sieht meine ganze Gewinnprüfung so aus. Aber es geht immer noch nicht. Aber rein logisch müsste es für mich gehen. (Das ist erst die überprüfung von A. Bei B wärs ja dann fast dasselbe (:
for(int i=0;i<=7;i++)
{
for(int j=0;j<=7;j++)
{
if(Spielfeld[i][j] == SpielerA)
{
j++;
if(Spielfeld[i][j] == SpielerA)
{
j++;
if(Spielfeld[i][j] == SpielerA)
{
j++;
if(Spielfeld[i][j] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
else if(Spielfeld[i+1][j] == SpielerA)
{
i++;
if(Spielfeld[i][j] == SpielerA)
{
i++;
if(Spielfeld[i][j] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
}
Wenn man die Bedingungen jetzt noch ein klein bißchen kompakter schreibt (statt viele if's hintereinander einfach mit "&&" verknüpfen) wird die Sache sogar wieder übersichtlich - selbst für alle zu prüfenden Zeilen, Spalten und Diagonalen.
Und wenn Du die dann so übersichtlich geschrieben hast, wird's Dir sicher wie Schuppen aus den Haaren fallen, daß Du DA auch wieder drei Schleifen draus basteln kannst, und die Sache ist sogar mit Übung von Techniken richtig kompakt geworden...
//pseudocode
pruefeGewinnerSpielerA()
{
for(x; x < 8; x++)
{
for(y; y <8 ; <++)
{
if(spieldFeld[x][y] == SpielerA) //erstmal all Steine von Spieler A finden, und auf jeden einzeln prüfen
{
pruefeVertical(x,y,SpielerA);
pruefeHorizontal(x,y,SpielerA);
pruefeDiagonal(x,y,SpielerA);
}
}
}
}
pruefeHorizontal(int x, int y, char SpielerA)
{
//VORHER NOCH PRÜFEN, OB DIE KOORDINATEN ÜBERHAUPT EXISTIEREN!
//pruefe nach rechts
if(spielfeld[x+1,y] == SpielerA && spielfeld[x+2,y] == SpielerA && spielfeld[x+3,y] == SpielerA)
{
//gewonnen!
}
//pruefe nach links
if(spielfeld[x-1,y] == SpielerA && spielfeld[x-2,y] == SpielerA && spielfeld[x-3,y] == SpielerA)
{
//gewonnen!
}
}
pruefeVertical(int x, int y, char SpielerA)
{
//VORHER NOCH PRÜFEN, OB DIE KOORDINATEN ÜBERHAUPT EXISTIEREN!
//pruefe nach unten
if(spielfeld[x,y+1] == SpielerA && spielfeld[x,y+2] == SpielerA && spielfeld[x,y+3] == SpielerA)
{
//gewonnen!
}
//pruefe nach oben
if(spielfeld[x,y-1] == SpielerA && spielfeld[x,y-2] == SpielerA && spielfeld[x,y-3] == SpielerA)
{
//gewonnen!
}
}
pruefeDiagonal(int x, int y, char SpielerA)
{
//VORHER NOCH PRÜFEN, OB DIE KOORDINATEN ÜBERHAUPT EXISTIEREN!
//pruefe nach rechts unten
if(spielfeld[x+1,y+1] == SpielerA && spielfeld[x+2,y+2] == SpielerA && spielfeld[x+3,y+3] == SpielerA)
{
//gewonnen!
}
//pruefe nach links oben
if(spielfeld[x-1,y-1] == SpielerA && spielfeld[x-2,y-2] == SpielerA && spielfeld[x-3,y-3] == SpielerA)
{
//gewonnen!
}
//pruefe nach rechts oben
//pruefe nach links unten
}
So ist erstmal am übersichtlichsten. Du kannst auch in den Prüf-Funktionen eine for-Schleife 1-3 laufen lassen und x+i prüfen, dann wirds noch kleiner. ;)
Hab jetzt mal aufgeräumt. Aber ich komm immer noch nicht drauf. Vor allem das mit dem Vertikalen. Vom logischen her seh ich keine Fehler. Für mich sieht das logisch aus (:
for(int i=0;i<=7;i++)
{
for(int j=0;j<=7;j++)
{
if(Spielfeld[i][j] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j] == SpielerA && Spielfeld[(i++)][j] == SpielerA && Spielfeld[(i++)][j])
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
AHHHHHH! Du inkrementiers ständig! Du darfst bei
Spielfeld[i][(j++)] == SpielerA
nicht das j++ benutzen! Damit erhöhst du den wirklichen Wert der Variable. Das machst du in der if-Abfrage 3x. Deine Schleife startet bei j=0. Nach der if-Abfrage ist j bereits bei 3, wenn der Schleifenkörper abgeschlossen ist wird sogar korrekterweise nochmal inkrementiert und landet damit auf 4! Dh, die Schleife wird wenns hochkommt 2x durchlaufen. Also in der if-Abfrage mit +1,+2,+3 arbeiten, das manipuliert den Wert der Variable nämlich nicht;
int j = 5;
out ( j + 3); // 8
out( j ); // 5
--------------
int j = 5;
out ( j + 3); // 8
j++;
j++;
j++;
out( j ); // 8
out ( j + 3); // 11
for(int i=0;i<=7;i++)
{
for(int j=0;j<=7;j++)
{
if(Spielfeld[i][j] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j] == SpielerA && Spielfeld[(i+2)][j] == SpielerA && Spielfeld[(i+3)][j] == SpielerA)// && Spielfeld[(i+4)][j] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
Also die horizontale Schleife geht jetzt.
Aber das Vertikale geht immer noch nicht. WAS MACH ICH FALSCH?! :(
- weil du j in der "oberen" if immernoch inkrementierst
- spielen wir 4 gewinnt, und nicht 5 gewinnt, also kannst du in den If's den Teil mit den "j+4" weglassen. Weil (x,y = 1), (x,y+1=2), (x,y+2=3),(x,y+3=4), damit hast du vier Steine ;)
So muss das in etwa aussehen:
if(Spielfeld[i][j] == SpielerA && Spielfeld[i][(j+1)] == SpielerA && Spielfeld[i][(j+2)] == SpielerA && Spielfeld[i][(j+3)] == SpielerA)
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j] == SpielerA && Spielfeld[(i+2)][j] == SpielerA && Spielfeld[(i+3)][j] == SpielerA)
Ah, ich seh grade, der +4 Teil ist auskommentiert, dann hab ich nix gesagt! ;) Und wirf mal einen Blick auf meinen Pseudocode hier unter diesem Beitrag!
Ok ok. Aber mein Code sieht ja 1 zu 1 gleich aus (ausser die beschriftungen).
Und das Diagonale hab ich auch noch nicht gemacht.
for(int i=0;i<=7;i++)
{
for(int j=0;j<=7;j++)
{
if(Spielfeld[i][j] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA && Spielfeld[i][(j++)] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j] == SpielerA && Spielfeld[i+2][j] == SpielerA && Spielfeld[i+3][j] == SpielerA)// && Spielfeld[(i+4)][j] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
Ok, aber in der oberen gehts.
AAAAAAAAH, jetzt hab ich die IF schleife auch geändert. Jetzt gehts auch vertikal. *__*
Aber was ich nicht ganz verstehe, wieso prüfst du nach RECHTS und nach LINKS? Reicht es nicht so wie ich es gemacht habe? Also bei mir funktionierts :D
Warte, ich poste mal meinen ganzen Code unten dran (: Ich hab ein bischen viele Kommentare und so gemacht, aber im grossen und ganzen bin ich zufrieden :D
// 4_Gewinnt.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
int main()
{
//Variabeldefinitionen
char Spielfeld[8][8];
char SpielerA = 'A';
char SpielerB = 'X';
int SpielerEingabe1 = 0;
int SpielerEingabe2 = 0;
int ZaehlerA = 0;
int ZaehlerB = 0;
int GewinnerA = 0;
int GewinnerB = 0;
int Gewinne = 0;
//int xyz = 1; //War für Endlosschleife VOR Gewinnüberprüfung...
//printf("Vier Gewinnt\n");
//printf("by Marco Laim\n\n\n");
//Alle Felder mit einem Unterstrich füllen damit es einheitlich aussieht
for(int i=0;i<=7;i++)
{
for(int fuellen=0;fuellen<=7;fuellen++)
{
Spielfeld[i][fuellen] = ' ';
}
}
//Spielfeld[0][4] = 'A';
//Spielfeld[2][7] = 'X';
do
{
printf("4_Gewinnt\n");
printf("by Marco L.\n\n\n");
//Gewinnprüfung
//--------------------------------------------------------------------------------------------------------------------------------
for(int i=0;i<=7;i++)
{
for(int j=0;j<=7;j++)
{
if(Spielfeld[i][j] == SpielerA && Spielfeld[i][(j+1)] == SpielerA && Spielfeld[i][(j+2)] == SpielerA && Spielfeld[i][(j+3)] == SpielerA)// && Spielfeld[i][(j++)] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j] == SpielerA && Spielfeld[i+2][j] == SpielerA && Spielfeld[i+3][j] == SpielerA)// && Spielfeld[(i+4)][j] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j+1] == SpielerA && Spielfeld[i+2][j+2] == SpielerA && Spielfeld[i+3][j+3] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
//Ende Gewinnprüfung
//--------------------------------------------------------------------------------------------------------------------------------
//Ausgabe Spielfeld
printf(" 0 1 2 3 4 5 6 7\n");
printf(" +---+---+---+---+---+---+---+---+\n");
printf("0 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[0][0],Spielfeld[0][1],Spielfeld[0][2],Spielfeld[0][3],Spielfeld[0][4],Spielfeld[0][5],Spielfeld[0][6],Spielfeld[0][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("1 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[1][0],Spielfeld[1][1],Spielfeld[1][2],Spielfeld[1][3],Spielfeld[1][4],Spielfeld[1][5],Spielfeld[1][6],Spielfeld[1][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("2 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[2][0],Spielfeld[2][1],Spielfeld[2][2],Spielfeld[2][3],Spielfeld[2][4],Spielfeld[2][5],Spielfeld[2][6],Spielfeld[2][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("3 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[3][0],Spielfeld[3][1],Spielfeld[3][2],Spielfeld[3][3],Spielfeld[3][4],Spielfeld[3][5],Spielfeld[3][6],Spielfeld[3][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("4 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[4][0],Spielfeld[4][1],Spielfeld[4][2],Spielfeld[4][3],Spielfeld[4][4],Spielfeld[4][5],Spielfeld[4][6],Spielfeld[4][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("5 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[5][0],Spielfeld[5][1],Spielfeld[5][2],Spielfeld[5][3],Spielfeld[5][4],Spielfeld[5][5],Spielfeld[5][6],Spielfeld[5][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("6 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[6][0],Spielfeld[6][1],Spielfeld[6][2],Spielfeld[6][3],Spielfeld[6][4],Spielfeld[6][5],Spielfeld[6][6],Spielfeld[6][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("7 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[7][0],Spielfeld[7][1],Spielfeld[7][2],Spielfeld[7][3],Spielfeld[7][4],Spielfeld[7][5],Spielfeld[7][6],Spielfeld[7][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
//Welcher Spieler ist dran?
if(ZaehlerA<=ZaehlerB)
{
printf("Spieler 1 ist dran!\n");
printf("Bitte gib die Zeile an: ");
scanf("%i", &SpielerEingabe1);
fflush(stdin);
printf("Bitte gib die Spalte an: ");
scanf("%i", &SpielerEingabe2);
fflush(stdin);
Spielfeld[SpielerEingabe1][SpielerEingabe2] = SpielerA;
ZaehlerA++;
}
else if(ZaehlerA>ZaehlerB)
{
printf("Spieler 2 ist dran!\n");
printf("Bitte gib die Zeile an: ");
scanf("%i", &SpielerEingabe1);
fflush(stdin);
printf("Bitte gib die Spalte an: ");
scanf("%i", &SpielerEingabe2);
fflush(stdin);
Spielfeld[SpielerEingabe1][SpielerEingabe2] = SpielerB;
ZaehlerB++;
}
//Spielfeld neu ausgeben
system("CLS");
}
//Solange bis jemand gewonnen hat
while(Gewinne != 1);
if(GewinnerA == 1)
{
printf("Spieler A hat das Spiel gewonnen! Gratulation\n");
}
else
{
printf("Spieler B hat das Spiel gewonnen! Gratulation\n");
}
printf("Bitte ENTER druecken");
getchar();
return 0;
}
Du inkrementierst immernoch xD Hier dein letzter Code, ich habs mit -->><<<--- markiert^^ vergeliche das mit meinen Codeschnipsel^^
for(int i=0;i<=7;i++)
{
for(int j=0;j<=7;j++)
{
if(Spielfeld[i][j] == SpielerA && Spielfeld[i][(----------->>>j++<<<--------)] == SpielerA && Spielfeld[i][(----------->>>j++<<<--------)] == SpielerA && Spielfeld[i][(----------->>>j++<<<--------)] == SpielerA && Spielfeld[i][(----------->>>j++<<<--------)] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j] == SpielerA && Spielfeld[i+2][j] == SpielerA && Spielfeld[i+3][j] == SpielerA)// && Spielfeld[(i+4)][j] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
Ansonsten haste eigentich recht, nach Links musst du nich unbedingt prüfen. Ich bin bisher von einem Stein ausgegangen, von dem ich absolut garnichts weiß, außer seiner Position. Und in dem Fall musst du jede Richtung checken.
Oh, das mit dem Inkrementieren hab ich jetzt raus :DD
Jetzt läufts.
ABER, beim Diagonalen, muss man ja 4 machen.
- Von Oben links nach unten rechts
- Von unten links nach oben rechts
- Von oben rechts nach unten links
- Von unten rechts nach oben links
Seh ich das richtig? ^^
Korrekt, zwei davon hab ich in meinem pseudocode schon geschrieben, die anderen bekommste selber hin ;)
Jap, danke.
Und die Gewinnüberprüfung sollte ich unten hintun, also NACH der Spielereingabe oder?
Ok ok ok.
Noch was. Bei meiner Diagonalen Überprüfung, gewinnt man schon, wenn man nur 3 Steine Diagonal hat. Aber ich bin mir 99% sicher dass mein Code korrekt ist.
kannst du dir das bitte mal anschauen? (:
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j+1] == SpielerA && Spielfeld[i+2][j+2] == SpielerA && Spielfeld[i+3][j+3] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i-1][j-1] == SpielerA && Spielfeld[i-2][j-2] == SpielerA && Spielfeld[i-3][j-3] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
Sollte stimme, oder?
Dankeeeee
Sieht auf den ersten Blick nich verkehrt aus. Du solltest jetzt herausfinden, in welcher der beiden Abfragen das falsche Ergebnis herauskommt, am besten durch paar printf. Wenn du so die Abfrage gefnden hast, lasse dir die Ergebnisse der Koordinaten ausgeben, dann kannst du kontrollieren! ;)
€dit: haha, ich habs zwar nich gefunden, aber such nochmal nach falschen Inkrementierungen. gerade bei j-1 macht sich das bemerkbar.
j = 5; // angenommen j ist 5
j-1 = SpielerA // 4 = SpielerA / wir prüfen j-1
j++; // irgendwo wird inkrementiert, j is jetzt 6 statt 5
j-2 = SpielerA // 4 = SpielerA / wir prüfen WIEDER die 4, weil 6-2, und die hat den selben Wert^^ So könnten 3 Steine reichen!
Aber du hast ja gesagt ich soll 'etwas'+1 machen und nicht ++
Also nehm ich an das gilt auch für - oder? Also 'etwas'-1 und nicht --
Ich könnte ja einfach nochmal ein Spielfeld[i-4][j-4] machen xD
Oder wäre das unprofessionell? :D
Und wie siehts bei B aus? Kommt das in die gleiche IF schleife? Einfach untendran nochmal ein paar ELSE IF's machen?
Is schon richtig. ++ oder -- hast du ausschließlich in der for()-Schleife. Ansonsten benutst du j+x.
Ich wollte dir nur erklären, wie es zu dm Phänomen gekommen sein konnte. Angenommen j2 bis j5 hat Spieler A gesetzt. Dein Prüfalgorhytmus fängt ja nun bei j0 an. Findet da nichts, nimmt sich j1 vor, auch nichts. Bei j2 wirds jetzt also interessant. j2 ist SpielerA. Also wird jetzt noch j2+1, j2+2, j2+3 geprüft. Wenn jetzt irgendwo in diesen Checks noch ein inkrement/dekrement versteckt ist, dann kann es sein, dass du nicht zB j2+2 prüfst, sondern j3+2(3 zum gewinnen) oder gar j1+2(5 zum gewinnen).
Für den B Check schreibst du entweder das ganze Konstrukt nochmal, oder integrierst die B Checks mit in die if-Abfrage.
Wieso geht dieser Code nicht :/
Es klingt sooooo logisch, aber geht und geht einfach nicht weiter.
Wenn du jetzt z.B. irgendwo oben bei 0 0 anfängst, und dann aber deine 4er Reihe in der Mitte irgendwo machst, geht es nicht. Dann kannst du so viele Reihen machen wie du willst, es geht nie.
Weisst du woran das liegt? Also Inkremente hab ich jetzt keine mehr. 100%ig nicht (:
for(int i=0;i<=7;i++)
{
for(int j=0;j<=7;j++)
{
if(Spielfeld[i][j] == SpielerA && Spielfeld[i][(j+1)] == SpielerA && Spielfeld[i][(j+2)] == SpielerA && Spielfeld[i][(j+3)] == SpielerA)// && Spielfeld[i][(j++)] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j] == SpielerA && Spielfeld[i+2][j] == SpielerA && Spielfeld[i+3][j] == SpielerA)// && Spielfeld[(i+4)][j] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j+1] == SpielerA && Spielfeld[i+2][j+2] == SpielerA && Spielfeld[i+3][j+3] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i-1][j-1] == SpielerA && Spielfeld[i-2][j-2] == SpielerA && Spielfeld[i-3][j-3] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i-1][j+1] == SpielerA && Spielfeld[i-2][j+2] == SpielerA && Spielfeld[i-3][j+3] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
else if(Spielfeld[i][j] == SpielerA && Spielfeld[i+1][j-1] == SpielerA && Spielfeld[i+2][j-2] == SpielerA && Spielfeld[i+3][j-3] == SpielerA)
{
GewinnerA = GewinnerA + 1;
Gewinne = Gewinne + 1;
}
}
}
Hilf mir o.0 :DD
Sieht erstmal sauber aus :/ Mach mal Ausgaben in die einzelnen if-Blöcke rein. Dann siehst du, ob die Abfragen wenigstens greifen, und ob bei deiner Gewinner ermittlung was schiefläuft. Du ..............
xD .... dein Spielfeld hat Felder zwischen 0 und 7. Wenn du Zelle 0,0 prüfst, und diagonal 0-1,0-1 machst, komsmt du im Spieldfeld auf -1,-1, was nicht existiert. Und eigentlich nen Fehler schmeißen müsste. Also, vorher prüfen, ob zu prüfende Koordinaten überhaupt existieren. Was ich im übrigen auch im Pseudocode unten mehr als deutlich geschrieben habe :D
// 4_Gewinnt.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
int main()
{
//Variabeldefinitionen
char Spielfeld[8][8];
char SpielerA = 'A';
char SpielerB = 'X';
int SpielerEingabe1 = 0;
int SpielerEingabe2 = 0;
int ZaehlerA = 0;
int ZaehlerB = 0;
int GewinnerA = 0;
int GewinnerB = 0;
//int xyz = 1; //War für Endlosschleife VOR Gewinnüberprüfung...
//Alle Felder mit einem Unterstrich füllen damit es einheitlich aussieht
for(int i=0;i<=7;i++)
{
for(int fuellen=0;fuellen<=7;fuellen++)
{
Spielfeld[i][fuellen] = ' ';
}
}
//Spielfeld[0][4] = 'A';
//Spielfeld[2][7] = 'X';
do
{
printf("4_Gewinnt\n");
printf("by Marco L.\n\n\n");
//Gewinnprüfung
for(int i=0;i<=7;i++)
{
int counter = 0;
for(int j=0;j<=7;j++)
{
//Spielfeld[i][j] = SpielerA;
}
}
//Ausgabe Spielfeld
printf(" 0 1 2 3 4 5 6 7\n");
printf(" +---+---+---+---+---+---+---+---+\n");
printf("0 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[0][0],Spielfeld[0][1],Spielfeld[0][2],Spielfeld[0][3],Spielfeld[0][4],Spielfeld[0][5],Spielfeld[0][6],Spielfeld[0][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("1 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[1][0],Spielfeld[1][1],Spielfeld[1][2],Spielfeld[1][3],Spielfeld[1][4],Spielfeld[1][5],Spielfeld[1][6],Spielfeld[1][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("2 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[2][0],Spielfeld[2][1],Spielfeld[2][2],Spielfeld[2][3],Spielfeld[2][4],Spielfeld[2][5],Spielfeld[2][6],Spielfeld[2][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("3 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[3][0],Spielfeld[3][1],Spielfeld[3][2],Spielfeld[3][3],Spielfeld[3][4],Spielfeld[3][5],Spielfeld[3][6],Spielfeld[3][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("4 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[4][0],Spielfeld[4][1],Spielfeld[4][2],Spielfeld[4][3],Spielfeld[4][4],Spielfeld[4][5],Spielfeld[4][6],Spielfeld[4][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("5 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[5][0],Spielfeld[5][1],Spielfeld[5][2],Spielfeld[5][3],Spielfeld[5][4],Spielfeld[5][5],Spielfeld[5][6],Spielfeld[5][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("6 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[6][0],Spielfeld[6][1],Spielfeld[6][2],Spielfeld[6][3],Spielfeld[6][4],Spielfeld[6][5],Spielfeld[6][6],Spielfeld[6][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
printf("7 | %c | %c | %c | %c | %c | %c | %c | %c |\n",Spielfeld[7][0],Spielfeld[7][1],Spielfeld[7][2],Spielfeld[7][3],Spielfeld[7][4],Spielfeld[7][5],Spielfeld[7][6],Spielfeld[7][7]);
printf(" +---+---+---+---+---+---+---+---+\n");
//Welcher Spieler ist dran?
if(ZaehlerA<=ZaehlerB)
{
printf("Spieler 1 ist dran!\n");
printf("Bitte gib die Zeile an: ");
scanf("%i", &SpielerEingabe1);
fflush(stdin);
printf("Bitte gib die Spalte an: ");
scanf("%i", &SpielerEingabe2);
fflush(stdin);
Spielfeld[SpielerEingabe1][SpielerEingabe2] = SpielerA;
ZaehlerA++;
}
else if(ZaehlerA>ZaehlerB)
{
printf("Spieler 2 ist dran!\n");
printf("Bitte gib die Zeile an: ");
scanf("%i", &SpielerEingabe1);
fflush(stdin);
printf("Bitte gib die Spalte an: ");
scanf("%i", &SpielerEingabe2);
fflush(stdin);
Spielfeld[SpielerEingabe1][SpielerEingabe2] = SpielerB;
ZaehlerB++;
}
//Spielfeld neu ausgeben
system("CLS");
}
//Solange bis jemand gewonnen hat
while(GewinnerA != 1 || GewinnerB != 1);
printf("Bitte ENTER drücken");
getchar();
return 0;
}
Ich habs jetzt mal so gemacht. Also in der ersten Reihe horizontal gehts :D
ist das so in Ordnung oder werd ich mit der konstruktion später Probleme bekommen? (: