Gewinnabfrage für 4-Gewinnt in C

[robert (Gast)]

Also ich habe derzeit keine möglichkeit meinen Controller zu 
Programmieren da mein Paralell-Port kaputt ist, so geh ich morgen zu 
einem Freund bei dem es Funktioniert, jetz habe ich aber nur bis Montag 
Zeit mein Programm fertigzustellen, es funktioniert alles bis auf die 
Gewinnabfrage.
jetz würde ich gerne wissen ob das so funtionieren würde wie ich es 
Programmiert habe
also die Gesetzen steine werden in ein Array geschrieben.
Spielfeld[6][7]
1 für grün und
2 für rot
in meinem beispiel sind x und y immer der stein der als letztes gesetzt 
wurde
jetz würde ich gerne wissen ob meine gewinnabfrage so funktioniert wie 
ich sie geschrieben habe.

void gewinnabfrage(){
    
     for(m=1;m<=3;m++)       //Horizontal
     {
       if(spielfeld[x+m][y]==1) 
      {zaehler++;
      }
      if(spielfeld[x-m][y]==1)
      {zaehler++;
      }
     }
     if(zaehler>=4)win=1;
       else{            //Vertikal
       zaehler=0;
         for(m=1;m<=3;m++)
         {
           if(spielfeld[x][y-m]==1) 
          {zaehler++;
          }
      
         }
       }
       if(zaehler>=4)win=1;     
       else{            //Diagonal 1
       zaehler=0;
        for(m=1;m<=3;m++)
         {
           if(spielfeld[x-m][y-m]==1) 
          {zaehler++;
          }
          if(spielfeld[x+m][y+m]==1) 
          {zaehler++;
          }
      
         }
       }
     if(zaehler>=4)win=1;
       else{             //Diagonal 2
       zaehler=0;
         for(m=1;m<=3;m++)
         {
           if(spielfeld[x+m][y-m]==1) 
          {zaehler++;
          }
          if(spielfeld[x-m][y+m]==1) 
          {zaehler++;
          }
      
         }
       }
 }

[DirkB (Gast)]

Probier es dochaus.
Die Abfrage sollte mit jedem C-Compiler zu machen sein.
Auch der zu deinem System gehört.

Auch Online, z.B. codepad.org

Oder im Simulator.

[robert (Gast)]

ich habe den code ja in keil geschrieben und bereist compiliert, also es 
gibt keine errors, ich wollte nur fragen ob es von der logik her richtig 
geschrieben ist, ob das programm so wie ich es geschrieben habe auch 
seine zweck erfüllt

[Looser (Gast)]

robert schrieb:
> ich habe den code ja in keil geschrieben und bereist compiliert, also es
> gibt keine errors,

tja, dann kannst du jetzt den Simulator anwerfen, im Keil ;-)

[robert (Gast)]

aber am simulator seh ich doch keine led-matrix, und das seh ich nicht 
wie das funtioniert, außerdem hab ich keine ahnung wie der funktioniert, 
kann man dort eine mehrfarbige led-matrix und taster simulieren? und 
wenn ja wie?

[Looser (Gast)]

Du kannst dort dein Programm debuggen. Du kannst die Inhalte der 
Variablen aunschauen, das Programm anhalten, schrittweise ausführen, 
Werte ändern, ...
Und so siehst du, ob das Programm das macht, was du willst. Bunte Knöpfe 
brauchst du nicht, schließlich weisst du doch was du programmiert hast.

[robert (Gast)]

ja, wie setze ich z.b. den taster p3.1 und wie schaue ich nun was dann 
mit p0 passiert???

[Looser (Gast)]

Guckst du hier. 
http://www.keil.com/support/man/docs/uv4/uv4_sm_di_push_button.htm

[Floh (Gast)]

robert schrieb:
> void gewinnabfrage(){

Ich würde bei sowas lieber z.B. einen int zurückgeben, der dir sagt, 
0=kein Gewinner, 1=Rot gewonnen, 2=grün gewonnen.
So sparst du dir erstens die globale Variable, zweitens kannst du sobald 
du eine Viererreihe gefunden hast sofort beenden (mit return).
Außerdem wäre es meiner Meinung nach angebracht, den Zähler nur in der 
Funktion zu haben -> lokale Variable.

[... (Gast)]

Egal ob Simulator oder nicht, der Codeschnipsel oben wird jedenfalls 
nicht funktionieren. Und das geht gleich bei den ersten paar Zeilen los:

void gewinnabfrage(){
    
     for(m=1;m<=3;m++)       //Horizontal
     {
       if(spielfeld[x+m][y]==1)

Überleg mal was passiert, wenn der letzte Stein die Koordinate x=5 
hatte.
Und was passiert eigenlich, wenn der letze Stein rot war?

[... (Gast)]

Achso nochwas. Überlegt mal wie groß 'zaehler' in Deinen Zählschleifen 
werden kann. Und dann schau mal auf welchen Wert Du dann testest. Bei 
Dir kann man niemals gewinnen.

[DirkB (Gast)]

robert schrieb:
> aber am simulator seh ich doch keine led-matrix, und das seh ich nicht
> wie das funtioniert,

Du willst doch nur die Funktion gewinnabfrage() überprüfen.
Dazu brauchst doch auch nur deine Array spielfeld.
Das kannst du auch mit Testwerten vorbesetzen.

[robert (Gast)]

... schrieb:
> Überleg mal was passiert, wenn der letzte Stein die Koordinate x=5
> hatte.

ja dann geht das nicht ganz auf mit dem dimensionen vom array, aber wie 
mache ich das dann? -.-
... schrieb:
> Und was passiert eigenlich, wenn der letze Stein rot war?

void gewinnabfrage(){
     if(spielfeld[x][y]==1)a=1;
     else a=2;
    
     for(m=1;m<=3;m++)       //Horizontal
     {
       if(spielfeld[x+m][y]==a) 
      {zaehler++;
      }
      if(spielfeld[x-m][y]==a)
      {zaehler++;
      }
     }
     if(zaehler>=4)win=1;

dann villeicht so?

[Ulrich (Gast)]

So klappt es auch noch nicht ganz. Die 4 Steine müssen zusammenhängend 
sein. So wird ein Bereich von 3 nach links bis 3 nach rechts überprüft, 
ob da 4 passende drin sind. Man muss aber aufhören zu zählen, wenn 1 
Stein nicht mehr passt.  Das wäre dann also eher je eine While Schleife 
nach links und rechts bis maximal 3, und dann die Summe von links und 
rechts anschauen.

Beim Index muss man dann noch aufpassen, wenn man den Rand des Feldes 
erreicht. Eventuell am Rand einfach noch je 3 leere Reihen vorsehen und 
das Feld dann 13 breit machen statt 7.

Wenn das Programm nicht nur Mensch gegen Mensch spielen soll, sondern 
mit eigener Intelligenz, würde ich die endliche Zahl der 
Gewinnmöglichkeiten (ca. 200) nutzen. Das sollte auch noch für einen µC 
passen - sowohl vom Speicher, als auch von der Geschwindigkeit.

[robert (Gast)]

jetz wollte ich gerade versuchen das array größer zu machen, jetzt heißt 
es beim compilieren data segment too large. was jetzt?
geht das auch ohne das ich das array so groß machen muss?
wie kann man das sonst mit den rändern regeln?

[Ulrich (Gast)]

Data Segment zu groß heißt das der Speicher (RAM) ausgeht.

Bei den Rändern kann man es auch so machen, das man noch extra 
kontrolliert das (x+m) auch im Bereich 1-7 liegt. Also dann Schleifen 
etwa der Form

m=1;
While ( (m < 4)&&((x+m)<=7) && (spielfeld[x+m][y]==a)) m++;

[R. M. (rmax)]

Statt vom neuen Stein aus nach links und rechts zu laufen, könntest Du 
horizontal einfach immer über die ganze Zeile, in der der neue Stein 
gelandet ist und dabei die zusammenhängenden Steine der zu überprüfenden 
Farbe zählen. Hat der Zähler vier erreicht, mit "Gewonnen" 
herausspringen, bei einem Stein der anderen Farbe, den Zähler 
zurücksetzen.

Vertikal kannst Du den Überlauf am unteren Rand dadurch vermeiden, daß 
Du die Zählschleife überhaupt nur dann startest, wenn schon mindestens 
vier Steine im entsprechenden Schacht liegen. Sind weniger Steine im 
Schacht, kann in der Richtung ja noch kein Sieg vorliegen. Oben kann es 
eigentlich keinen Überlauf geben, denn in einen vollen Schacht kann man 
ja keinen weiteren Stein werfen (das muß der Programmteil, der für's 
Einwerfen zuständig ist, natürlich sicherstellen).

Für die Diagonalen sollte es auch möglich sein, die Schleifen so zu 
gestalten, daß sichergestellt ist, daß sie nur maximal von Rand zu Rand 
laufen aber niemals darüber, aber das tüftle ich heute nicht mehr aus.