| Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
| Autor |
Nachricht |
cp+no0B
Gast
|
 Verfasst am: 17. Apr 2005 12:41 Titel: Vier Gewinnt - Vier Steine in einer Reihe |
 |
|
Hi
Wir haben die Aufgabe das Spiel Vier-gewinnt zu programmieren...
Das Spielfeld und das Setzen der Steine habe ich, doch wie mache ich das, dass er den Sieg feststellt, falls vier Steine in einer Reihe bzw. Diagonal gelegt worden sind ?
Hier der bisherige Code :
| Code: | //---------------------------------------------------------------------------
#include <stdlib.h>
#include <conio.h>
#include <iostream.h>
#define rot 44
#define blau 3
#define gelb 30
//---------------------------------------------------------------------------
// Globale Variable und Konstanten
//---------------------------------------------------------------------------
// Spielfeld hat 8 Spalten(x) und 7 Zeilen (y)
int feld[8][7];
bool gewonnen=false, voll=false, abgebrochen=false;
//---------------------------------------------------------------------------
// Funktionsdeklarationen
//---------------------------------------------------------------------------
void erklaerung();
void spielen();
bool nochmal();
void neufeld();
void setzen(int s);
void pruefen();
void siegerehrung(int s);
//---------------------------------------------------------------------------
// Hauptprogramm
//---------------------------------------------------------------------------
void main()
{
// Erklärung für Benutzer
erklaerung();
do spielen(); while ( nochmal() );
}
//---------------------------------------------------------------------------
// Funktionsdefinitionen
//---------------------------------------------------------------------------
void erklaerung()
{ cout<<""<<endl; getch();
}
//---------------------------------------------------------------------------
void spielen()
{ clrscr();
// Spielfeld zeichnen und Variable initialisieren
neufeld();
int spieler=2;
do
{
// Spielerwechsel
if (spieler==1) spieler=2; else spieler=1;
// Stein setzen
setzen(spieler);
gewonnen=false;
// Prüfen
if (!abgebrochen) pruefen();
// Wenn gewonnen dann Siegerehrung, sonst weiter mit nächstem Spieler
if (gewonnen ) siegerehrung(spieler);
}
while( !gewonnen && !voll && !abgebrochen);
}
//---------------------------------------------------------------------------
bool nochmal()
{ cout<<"Nochmal? j/n"<<endl;
char t=getch();
if(t=='j') return true;
else return false;
}
//---------------------------------------------------------------------------
void neufeld()
{ cout<<"Ich zeichne ein neues Feld"<<endl; getch();
for(int x=0; x<8; x++)
for (int y=0; y<7; y++)
feld[x][y]=0;
for (int z=0;z<7;z++)
{ textcolor(blau);
gotoxy(16,3*z+4);cprintf("|| || || || || || || || ||");
gotoxy(16,3*z+5);cprintf("|| || || || || || || || ||");
gotoxy(16,3*z+6);cprintf("||___||___||___||___||___||___||___||___||");
}
gotoxy(16,22);cprintf("|| || || || || || || || ||");
gotoxy(16,23);cprintf("|| || || || || || || || ||");
gotoxy(16,24);cprintf("||===||===||===||===||===||===||===||===||");
gotoxy(16,25);cout<<" 1 2 3 4 5 6 7 8"<<endl;
}
//---------------------------------------------------------------------------
void setzen(int s)
{
gotoxy(20,27); cout<<"Abbruch mit ESC Spieler "<<s<<" setzt in Spalte ";
char t;
int spalte;
bool spaltevoll=false;
do
{ do
t=getch();
while ( ! (t=='1' || t=='2' || t=='3'|| t=='4' || t=='5' || t=='6' ||
t=='7' || t=='8' || t==27));
if (t==27) { abgebrochen=true; return; }
spalte=t-49; // spalte geht von 0 bis 7
if (feld[spalte][0] !=0 )spaltevoll=true;
}
while ( spaltevoll);
// Stein fallen lassen in erste freie Stelle
int y=0;
while(feld[spalte][y]==0 && y<7) y++; // erste besetzte Zeile gefunden
feld[spalte][y-1]=s; // Stein setzen
// einzeichnen
if (s==1)
{ gotoxy(spalte*5+18,y*3+1); textcolor(rot);cprintf("°°°");
gotoxy(spalte*5+18,y*3+2); textcolor(rot);cprintf("°°°");
}
else { gotoxy(spalte*5+18,y*3+1); textcolor(gelb);cprintf("///");
gotoxy(spalte*5+18,y*3+2); textcolor(gelb);cprintf("///");
}
}
//---------------------------------------------------------------------------
void pruefen()
{ cout<<""<<endl; getch();
}
//---------------------------------------------------------------------------
void siegerehrung(int s)
{ cout<<"Ich ehre den Sieger "<<s<<endl; getch();
}
//---------------------------------------------------------------------------
|
Ich benutze Borland 1^^...
danke
cu |
|
| Nach oben |
|
 |
|
|
Gast
|
| Verfasst am: 17. Apr 2005 21:02 Titel: |
|
|
Im Idealfall prüfst du nach jedem gesetzten Spielstein die Umgebung des Steins.
Du kennst die Position des letzten Spielsteins (x, y). Nur dieser Spielstein kann zu einem Sieg beitragen, denn sonst hätte der Spieler schon vorher gewonnen.
Außerdem kennst du die Farbe F des Steins.
Alles, was du nun tun musst, ist von der aktuellen Position (x, y) die Umgebung abzusuchen. Ich mache ein Beispiel für die Waagerechte.
// In-Einer-Reihe-Counter auf 0
c = 0
// gehe 3 Schritte nach links und zähle gleichfarbige Steine
Für i = x-1, x-2, x-3
Ist i ausserhalb des Spielfeldes: Schleife abbrechen
Prüfe Spielstein (i, y) auf Farbe F.
Wenn gleich: c = c+1
Wenn ungleich: Schleife abbrechen
// gehe 3 Schritte nach rechts und zähle
Für i = x+1, x+2, x+3
Ist i ausserhalb des Spielfeldes: Schleife abbrechen
Prüfe Spielstein (i, y) auf Farbe F.
Wenn gleich: c = c+1
Wenn ungleich: Schleife abbrechen
Wenn c >= 3: Spieler mit Farbe F hat gewonnen
Sonst: c = 0, weiter mit Diagonalen und Senkrechten
Die Idee sollte klar werden. Den Prüfalgorithmus kann man erheblich verkürzen, wenn man die Schrittrichtung in einem Vektor darstellt:
(1, 0) - Schritt nach rechts
(-1, 0) - Schritt nach links
(0, 1) - Schritt nach oben
(0, -1) - Schritt nach unten
(1,1) - Schritt nach rechts oben
etc.
Wenn du den Richtungsvektor (b1, b2) vorgibst, dann musst du die Steine in der Umgebung durch (x, y) + (b1, b2) ; (x, y) + 2*(b1, b2) ; ... absuchen und erhälst so eine Strategie für alle Richtungen. |
|
| Nach oben |
|
|
mr. black
Anmeldungsdatum: 20.02.2005
Beiträge: 39
Wohnort: Krumbach
|
| Verfasst am: 20. Apr 2005 19:28 Titel: |
|
|
warum machst dus eigentlich mit
int feld[SPALTE] [ZEILE];
So ists besser, da es im Stack auch so aufgebaut ist.
und daher auch besser mit Scleifen durchlaufbar ist,
da der Pointer immer um eins versetzt werden muss und
nicht um ZEILE:
int feld[ZEILE] [SPALTE];
_________________
Zeit ist, was man auf einer Uhr abliest. A.E. |
|
| Nach oben |
|
|
|
|
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
Du kannst Dateien in diesem Forum nicht posten
Du kannst Dateien in diesem Forum nicht herunterladen
|
|
FAQ
Suchen
Mitgliederliste
Benutzergruppen
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
