Reversi-Probleme mit Funktionen

[tankm26]

Hallo!


Bei meiner Informatik-HA hänge ich leider an folgenden Problemen:

1.Aufgabe 2 des Zettels, nämlich eine function 'pruefen' zu programmieren, die mir einzelne Teile eines Stringgrids/arrays auf den Inhalt/den zugewiesenen Wert überprüft, zu erfüllen.

1.2 wie man Problem 1 programmiert

2 wie man das Ergebnis, nämlich die Anzahl der eingeschlosssenen Gegnersteine, irgendwo anzeigt

3 wie man die function pruefen überhaupt in einer procedure aufruft


Das ich nicht erwarte, dass ihr die Hausaufgabe fertig programmiert, ist klar, aber für jeden Hinweis/Lösungsansatz wäre ich dankbar.

Wieland


:wall: oh mann, die sommerferien waren irgendwie zu lang, ich hab ja ALLES vergessen! :coder2:

[NicNacMan]

hi,

ich würde in der function pruefen als erstes mal x mit dx bzw y mit dy vergleichen,
um raus zu bekommen, ob du die waagerechten, horizontalen oder diagonalen überprüfen musst.
dann natürlich die randwerte, also den ersten und letzten stein.

und an der spielfeldClick procedure würde ich auch nochmal was verändern.

Delphi-Quellcode:

if feld[spielfeld.Col, spielfeld.Row]=1 then // wieso 1, nimm doch rot
  begin
    dransein:=1; // bringt zwischen case dransein of rot: begin ... end; end; auch nicht sehr viel, wenn die konstante rot = 1 ist.
    feld[spielfeld.Col, spielfeld.Row]:=1;  // is doch überflüssig
  end;

damit wäre dann die ganze abfrage mehr oder weniger überflüssig.
da das auch noch für den fall, dass dransein = blau ist vorkam,
konnte man den code deutlich vereinfachen.

statt deinen 28 zeilen wären es so nur 11;

Delphi-Quellcode:

if (feld[spielfeld.Col, spielfeld.Row] = 0) then
  begin
    feld[spielfeld.Col, spielfeld.Row] := dransein;
    case dransein of
      rot : dransein := blau;
      blau: dransein := rot;
    end;
    spielfeld.Refresh;
  end
else if (feld[spielfeld.Col, spielfeld.Row] <> dransein) then
  Application.MessageBox('Das Feld ist schon belegt!', 'Fehler');

[tankm26]

Danke schonmal für deine Mühe, den spielfeldclick-Quellcode habe ich schon ausprobiert, ich muss nur noch die Möglichkeit ergänzen, dass man nicht auf die Spielsteine der eigenen Farbe klicken darf.

Die pruefen-Funktion werde ich mir gleich mal überlegen.

edit:

Delphi-Quellcode:

das ist nun der fertige spielfeldclick-code

procedure TForm1.spielfeldClick(Sender: TObject);
begin
  if (feld[spielfeld.Col,spielfeld.Row]=0) then
  begin 
    feld[spielfeld.Col,spielfeld.Row]:=dransein;
    case dransein of 
      rot : dransein := blau;
      blau: dransein := rot; end;
    spielfeld.Refresh; end 
else   Application.MessageBox('Das Feld ist schon belegt!', 'Fehler');
end;

[tankm26]

also, aus dieser aufgabe/function pruefen werde ich nicht schlau....

gibt es da eine elegante Möglichkeit, bei der man sich nicht die Finger Wund tippt?
Vielleicht ein Beispiel für eine Richtung?

[DGL-luke]

Ist doch eigentlich ganz einfach: du musst von x|y nach dx|dy überprüfen, welche steine des gegners eingeschlossen sind. schau dir ienfach mein kleines bild an ;)

[tankm26]

ich werde das mal durchdenken...

soll ich dann 'n paar zeilen schreiben für jede Richtung, mit ner for-Schleife?

edit 1: Oh mann, ich komm nich weiter und das nervt

[DGL-luke]

ich würde so vorgehen:

1. zu prüfende Felder ermitteln:
a)waagerecht?: y=dy -> zu prüfende felder: x|y, x+1|, x+2| .... dx|y
b)senkrecht?: x=dx? -> zu prüfende felder: x|y, x|y+1,x|y+2 .... x|dy
c)diagonal?: selber machen :P

2. felder prüfen: mit for-schleife durchgehen und schauen: ist da ein gegnerischer stein? sind die steine in einer linie? usw. usf.

[tankm26]

ich werd mal drüber nachdenken. Aber ersteinmal muss ich glaube ich mal frische Luft schnappen. Danke schonmal.


so, jetzt wollen wir doch mal schauen...

sollen x und y jeweils die position des aktuell angewählten spielfeldes sein?

dx und dy die Begrenzung für 2.?

soll ich 1. mit if-formeln machen? womit sonst? for-schleifen? und vor allem was soll ich da schreiben?

ojeojeojeojeoje

so in etwa?

Delphi-Quellcode:

 x:=spielfeld.Row;
    y:=spielfeld.Col;
    label1.Caption:=IntToStr(x);
    label2.Caption:=IntToStr(y);
      if feld [(x+1),y]<>dransein then begin
        if feld [(x+2),y]<>dransein then begin
          if feld [(x+3),y]<>dransein then begin
           if feld [(x+4),y]<>dransein then begin
             if feld [(x+5),y]<>dransein then begin
               if feld [(x+6),y]=dransein then begin
                 zahl:=zahl+6;

wie kann ich die function pruefen eigentlichg einbauen?
etwa so?
label3.Caption:=IntToStr(pruefen);

[tankm26]

also, einbinden, muss ich dat folgendermaßen, oder?

label3.Caption:=IntToStr(pruefen(spielfeld.Col,spi elfeld.Row));

[Muetze1]

Moin!

Rekursive Funktionen!

Beispiel dazu

MfG
Muetze1

[tankm26]

Zitat:

Zitat von Muetze1

Moin!

Rekursive Funktionen!

Beispiel dazu

MfG
Muetze1

danke schonmal, das werde ich mir mal anschauen.

[DGL-luke]

wofür soll rekursivität beim prüfen gut sein?

pruefen prüft doch, wie viele steine eingeschlossen sind. zwischen zwei koordinaten.du brauchst also x|y und dx|dy.

das einbinden stimmt soweit, bloß dass es zwei params zu wenig sind.

[tankm26]

wie finde ich denn heraus bzw. wie kann ich es programmieren, dass das programm den nächsten gleichfarbigen Stein findet?

[DGL-luke]

einfach nach unten/rechts/rechts-oben durchprüfen, wann die selbe farbe kommt

aber das ist ja gar nicht deine aufgabe, oder?

EDIT: SOllst du eigentlich ein voll lauffähiges udn spielbares reversi machen, oder nur das, was in aufgaben drinsteht? also die zwei funktionen?

[tankm26]

nur die aufgaben, das programm wird eigentlich nie fertig

[DGL-luke]

dann mach erstmal istspielfeld, das ist einfacher ^^

[tankm26]

ich will ja nix sagen aber... istspielfeld ist ja wohl fertig, die muss ich nur noch verknüpfen

[DGL-luke]

dann helf ich dir hier mal mit n bisschen code auf die sprünge :)

Delphi-Quellcode:

function pruefen(x,y,dx,dy:integer):integer; //pruefen ist eigentlich nur ein wrapper für die drei richtigen prüffunktionen
var
begin
if x=dx then //wenn es senkrecht ist
 result:=processvertical(x,y,dy)
else if y=dy then // wenn es waagerecht ist
 result:=processhorizontical(x,dx,y)
else //wenn es diagonal ist
 result:=processdiagonal(x,y,dx,dy); 
end;

function processvertical(x,y,dy:integer):integer;
var i:integer;
    count:integer;
    encplayer:integer; //farbe des eingeschlossenen
begin
sort(y,dy); //stellt sicher, dass es von oben nach unten geht - selber machen ;)

if not (feld[x,y]=feld[x,dy]) then //der erste stein muss die selbe farbe haben wie der letzte
 begin
  result:=-1; //Fehler!
  exit;       //Abbruch!
 end
else
 begin
  if      feld[x,y]=GRÜN then encplayer:=ROT
  else if feld[x,y]=ROT  then encplayer:=GRÜN;
  else  //wenn das feld leer ist
   begin
    result:=-1;
    exit;
   end;
 end;

count:=0; //initialisieren

for i := y+1 to dy-1 do //ersten und letzten stein auslassen
 begin
  if feld[x,i]=encplayer then count:=count+1;
  else
   begin
    result:=-2; //Kein fehler, aber keine geschlossene reihe
    exit;
   end;
 end;

result:=count;
end;

Es würde jetzt bereits schon fast (*) für senkrechte reihen funktionieren, unter der bedingungen, dass auch die einschließenden Steine in den bereich einbezogen werden.

Rückgabewerte:
>= 0: Menge der eingeschlossenen Steine
-1: Fehler
-2: Reihe unterbrochen

Den Rest solltest du selber schaffen :thumb:

(*): sort fehlt. es sollte so definiert sein:

Delphi-Quellcode:

procedure sort(var i,k:integer);

PS: zeig mal istspielfeld ;)

[tankm26]

also, das sieht ja reichlichst kompliziert aus.

Aber ich werde auch mal versuchen, das zu durchdenken/zu verstehen/ einzubauen.


die heute im unterricht propagierte lösung krame ich nachher mal heraus.

Danke schonmal für deine (eure) Hilfe!

[ichbins]

Ich habe selbst ein REVERSI-Spiel sammt KI geschrieben. Vielleicht hilft dir das ja irgendwie weiter. [Noch nicht ganz fertig, irgendwie hängt er sich nach ein paar Minuten immer auf. Ich wollte es eh mal als Open-Source posten]. Ich lade es mal hier hoch:

[tankm26]

so, pruefen und istspielfeld sind fertig

Die neue Aufgabe lautet: "spielende" und "umdrehen" zu programmieren.


Wieso funktioniert mein umdrehen eigentlich net?

[tankm26]

bin gerade dabei mein programm ein letztes mal zu überprügfen.

Hochladen tu ichs auch noch!

Danke an alle!

[Sidorion]

Ich würd mal eher so sagen: dx und dy sind jeweils entweder 1, 0 oder -1, wdann kannst du so vorgehen:

Delphi-Quellcode:

Procedure Prüfe(x,y,dx,dy: Integer): Integer;
Var
  lx,ly: Integer;
Begin
  lx:=x;
  ly:=y;
  Result:=0;
  While IsField(lx,ly)
  Do Begin
    ...Prüferei...
    Inc(lx,dx);
    Inc(ly,dy);
  End;
End;

so kannste alle Richtungen mit einem stück code erschlagen.

[tankm26]

du hast recht, so war es gedacht (und sogar schon von mir umgesetzt!)


hier ist mal die vorläufige endversion.

ein paar kleinigkeiten muss ich noch überprüfen

[tankm26]

Und das ist die fertige Version!