If-Verschachtelung in VierGewinnt - komisches Ergebnis

[Radon]

Hallo!

Ich bin dabei ein VierGewinnt zu programmieren, Delphi ist ziemliches Neuland für mich.

Ich hänge bei der Gewinnprüfung. Diese habe ich mal konzipiert und theoretisch dürfte sie (wenn ich keinen Denkfehler gemacht habe) auch funktionieren. Tut sie aber nicht. Nun glaube ich, dass es an Fehlern in der If-then-else Verschachtelung liegt.

Hier mal der Code:

Delphi-Quellcode:

//======================================================
// Gewinnüberprüfung
//======================================================

procedure TVierGewinnt.GewinnPruefung(GSpalte, GZeile: Integer);

var
  x, y, durchlauf: Integer;
  gewonnen: boolean;
begin
  for durchlauf := 0 to 3 do
  begin
    x := 0;
    y := 0;
    case durchlauf of
      0:  begin
          x := 1;
          y := 0;
          end;
      1:  begin
          x := 0;
          y := 1;
          end;
      2:  begin
          x := 1;
          y := -1;
          end;
      3:  begin
          x := -1;
          y := -1;
          end;
    end;

  if Feld[GSpalte + 1 * x, GZeile + 1 * y] = Spieler then
    if Feld[GSpalte + 2 * x, GZeile + 2 * y] = Spieler then
      if Feld[GSpalte + 3 * x, GZeile + 3 * y] = Spieler then
        begin
        gewonnen := true;
        end
      else
        if Feld[GSpalte - 1 * x, GZeile - 1 * y] = Spieler then
          begin
          gewonnen := true;
          end

    else
      if Feld[GSpalte - 1 * x, GZeile - 1 * y] = Spieler then
        if Feld[GSpalte - 2 * x, GZeile - 2 * y] = Spieler then
          begin
          gewonnen := true;
          end


  else
    if Feld[GSpalte - 1 * x, GZeile - 1 * y] = Spieler then
      if Feld[GSpalte - 2 * x, GZeile - 2 * y] = Spieler then
        if Feld[GSpalte - 3 * x, GZeile - 3 * y] = Spieler then
          begin
          gewonnen := true;
          end;


  if gewonnen = true then
  begin
    ShowMessage('Spieler '+IntToStr(Spieler)+' hat gewonnen!');
//    FreeAndNil(PaintBox1);
    FreeAndNil(VierGewinnt);
    gewonnen := false;
  end;


end;
end;

//======================================================
//======================================================

Ich weiß nicht genau ob ihr da meine Gedankengänge nachvollziehen könnt, das Prog hab ich nochmal im Anhang. Jedenfalls glaube ich, dass eben hier irgendwo der wurm drin ist, eine Abfrage in die Falsche geht und dadurch irgendwas schiefgelaufen ist. Merkmal ist, dass nur die vertikale gewinnprüfung funktioniert.

[glkgereon]

Ja, daran liegt es wohl...

hab mir den qt selber nicht angeschaut...aber nach deinen einrückungen zu urteilen sollte es wohl so sein:

Delphi-Quellcode:

  if Feld[GSpalte + 1 * x, GZeile + 1 * y] = Spieler then 
    begin
    if Feld[GSpalte + 2 * x, GZeile + 2 * y] = Spieler then 
      begin
      if Feld[GSpalte + 3 * x, GZeile + 3 * y] = Spieler then 
        gewonnen := true
      else 
        if Feld[GSpalte - 1 * x, GZeile - 1 * y] = Spieler then 
          gewonnen := true;  
      end
    else 
      begin
      if Feld[GSpalte - 1 * x, GZeile - 1 * y] = Spieler then 
        if Feld[GSpalte - 2 * x, GZeile - 2 * y] = Spieler then 
          gewonnen := true; 
      end;
    end
  else 
    begin
    if Feld[GSpalte - 1 * x, GZeile - 1 * y] = Spieler then 
      if Feld[GSpalte - 2 * x, GZeile - 2 * y] = Spieler then 
        if Feld[GSpalte - 3 * x, GZeile - 3 * y] = Spieler then 
          gewonnen := true; 
    end;

[shmia]

Wenn ein Spieler einen Stein wirft, muss man 7 verschiedene Richtungen
überprüfen. Die 8. Richtung wird nicht benötigt, da nach oben kein Stein liegen kann.
Also würde ich ein Array mit 8 Einträgen machen und für 7 Richtungen die Anzahl der
zusammenhängenen Steine zählen.
Immer zwei Richtungen gehören zusammen (nach links<=>nach rechts, nach linksoben<=>rechtsunten).
Am Ende bleiben also nur noch 4 Richtungen übrig.

Delphi-Quellcode:

TRichtung =(up, upright, right, downright, down, downleft, left, upleft); // die 8 Richtungen;
var
   anzahl[up..upleft]: integer;

// die gewinnbedingungen
// hier gewinnt die 3, da der Stein bei GZeile, Gspalte noch dazugerechnet werden muss
if (anzahl[up]+anzahl[down] >= 3) or
   (anzahl[upright]+anzahl[downleft] >= 3) or
   ....
   gewonnen := True;

[alzaimar]

7 Richtungen? Nö. Sind nur 4: 2x diagonal, waagerecht und senkrecht. Schließlich kann ich auch einen Stein in die Mitte einer 4er-Reihe legen.
Also:

Delphi-Quellcode:

Function CountPieces (x0,y0, dx,dy : Integer; aPlayer : TPlayer; Const aBoard : TBoard) : Integer;
  Function _Count (dx,dy : Integer) : Integer;
  Var 
    x,y : Integer;

  Begin
    x := x0;
    y := y0;
    while (x in [0..7]) and (y in [0..7]) and (aBoard[y,x] = aPlayer) do begin
      x := x + dx;
      y := y + dy;
      inc (Result);
    End;
 End;  
      
Begin
  Result := _Count (dx,dx) + _Count (-dx,-dy) - 1;
End;

Function IsWin (x0,y0 : Integer; aPlayer : TPlayer; Const aBoard : TBoard) : Boolean;
Begin
  Result := (CountPieces (x0,y0,-1,-1) > 3) 
         or (CountPieces (x0,y0,-1,+1) > 3) 
         or (CountPieces (x0,y0, 0,-1) > 3) 
         or (CountPieces (x0,y0,-1, 0) > 3) 
End;

Ich zähle also die Anzahl aufeinanderfolgender Steine gleicher Farbe erst in die eine, und dann in die umgekehrte Richtung. Ein Stein (nämlich er auf der Position (x0,y0)) wird immer mitgezählt, also ziehe ich von der Summe noch eins ab.

Ungetestet, sollter aber funktionieren. Die dauernde Prüfung, ob die Laufvariablen überhaupt noch im Feld sind, kann man sich ersparen, wenn man das TBoard als Array [-1..8,-1..8] Of TPlayer deklariert. Steine werden natürlich nur im Bereich 0..7 gelegt. der Rand wird mit '0' belegt.

[Radon]

uiii... hey danke für die Vorschläge

aber ich wollte das Programm mal komplett alleine schreiben. Die meisten vorschläge hören sich zwar gut an, verstehen tu ich sie aber nicht wirklich.

jedenfalls wollte ich nur dass meine Lösung fehlerfrei ist. Wenn meine funktioniert, werde ich versuchen sie schrittweise zu optimieren, auch mit hilfe eurer vorschläge.

@ glkgereon: das sieht schonmal brauchbar aus. werds gleich mal probieren.

[oldmax]

Hi
Wenn du deine If- Anweisungen verstehen willst, dann setze hinter jede If - Then ein Begin und begrenz mit end.
Also
If Irgendwas then
begin
if dasnächste then
begin
if weiteres then
begin
............
end;
end;
end;

oder natürlich auch
end else
begin
....
end;
Es mag bei deinen If- Verschachtelungen etwas aufwendig sein, aber solche geschachtelten Dinger sind die reinsten Holpersteine. Bei einer aufwendigen schreibweise ist zumeist ein Singlestep möglich und die Kontrolle, wo's Programm hinläuft.
und nun viel Spaß
Gruß oldmax