Überprüfung ob sich 3 oder mehrere buttons berühren

[kevSTAR]

Hallo Leute!

Ich programmiere gerade ein spiel in dem es darum das feld von sovielen monstern wie möglich zu befreien.
Ich habe ein 10 mal 10 Buttons großes Spielfeld, welche durch zufall mit einem "monster" bestückt werden.
Nun möchte ich bei Buttonclick checken ob sich 3 oder mehrere berühren

Mein problem:

_ _ _ _ _ _ _ _ _ _
|_|_|_|_|_|_|_|_|_|_|
|_|_|_|_|_|_|_|_|_|_|
|_|_|_|_|_|_|_|_|_|_|
|_|_|_|_|_|_|_|_|_|_|
|_|_|_|_|_|_|_|_|_|_|
|_|_|X|_|_|_|_|_|_|_|
|_|X|X|X|_|_|_|_|_|_|
|_|_|_|X|X|X|X|_|_|_|
|_|_|_|_|X|_|X|_|_|_|
|_|_|_|_|X|_|_|_|_|_|

Wenn es viel mehr als 3 berührungen gibt und diese in verschiedene richtungen gehen, wie kann ich dies am besten überprüfen?

[hoika]

Hm ??,

was berührt sich,die Buttons ?
Mache das Problem mal klarer.

Suchst du einen Berühren-Algorithmus,
oder geht es um die Buttons?

Ich würde erst mal eine Struktur für die anzuzeigenden Sachen machen,
z.B.

Delphi-Quellcode:

type
  TGame = array[1..10,1..10] of Boolean;
var
  Game: TGame;
begin
  Game[1,1]:= True;     // linke obere Ecke
  Game[10,10]:= True;   // rechte untere Ecke

Die Buttons benennst du "clever"
der links oben heisst z.B. Btn_1_1,
der rechts unten Btn_10_10

Beim Klick auf einen Button bekommst du den Namen des Buttons
und ermittelst per Pos/Copy aus dem Namen die Position.

Game[xPos,yPos] , xPos, yPos sind die aktuelle Position

zum suchen nach links schat du dir Game[xPos-1,yPos], Game[xPos-2,yPos] an,
nur Achtung, falls XPos vielleicht schin 1 ist.


So in etwa ...


Heiko

[kevSTAR]

ich habe ein Feld[1..10, 1..10] of TButton

diese sind angeordnet durch eine schleife zu einem 10x10 feld.
nun möchte ich eine funktion schreiben, welche den angeklickten button abcheckt und alle berührenden, solange es mindestens 3 sind auf ' ' setzt also die caption. 3 in einer reihe (vertikal oder horizontal) wären kein problem aber es geht auch um die ecke etc. wie oben beschrieben.

[xZise]

Ganz einfach:

Delphi-Quellcode:

var
  testPos : TPoint;
begin
  // Aktuelle Position in testPos schreiben

  // Dann überprüfen wir links/rechts/oebn/unten

  // Und dann:
  // Links oben:
  [testPos.x - 1][testPos.y - 1]

  // Links unten:
  [testPos.x - 1][testPos.y + 1]
end;

Mehr ist da nicht...

[shmia]

Vielleicht reden wir mal nicht von "Buttons" sondern von Steinen in einem Spielfeld.
Man nehme eine leere Liste von TPoint.

Delphi-Quellcode:

function CheckPoint(punkt : TPoint):integer;
begin
   result := 0;
   if AusserhalbSpielfeld(punkt) then
      Exit;
   // prüfe, ob der Punkt schon mal gefunden wurde
   if IstInListe(punkt) then
      Exit;

   if spielfeld[punkt.x, punkt.y] = belegt then
   begin
      FügeHinzuZurListe(punkt);
      Inc(result);   // den Stein zählen

      // und jetzt alle 4 Himmelrichtungen testen
      // rekursiver Aufruf
      Inc(Result, CheckPoint(Point(punkt.x+1,punkt.y));
      Inc(Result, CheckPoint(Point(punkt.x-1,punkt.y));
      Inc(Result, CheckPoint(Point(punkt.x,punkt.y+1));
      Inc(Result, CheckPoint(Point(punkt.x,punkt.y-1));
   end;
end;

Nachdem diese rekursive Funktion alle belegten Felder abgegrast hat, erhält man als
Ergebnis (Result) die Anzahl der zusammenhängenden Steine.

[edit]der Eingabeparameter "in" war ungeschickt gewählt, da ein Pascal Keyword. Er heisst jetzt "punkt"[/edit]

[xZise]

Zitat:

Zitat von shmia

Delphi-Quellcode:

function CheckPoint(in : TPoint):integer;
begin
   result := 0;
   if AusserhalbSpielfeld(in) then
      Exit;
   // prüfe, ob der Punkt schon mal gefunden wurde
   if IstInListe(in) then
      Exit;

   if spielfeld[in.x, in.y] = belegt then
   begin
      FügeHinzuZurListe(in);
      Inc(result);   // den Stein zählen

      // und jetzt alle 4 Himmelrichtungen testen
      // rekursiver Aufruf
      Inc(Result, CheckPoint(Point(in.x+1,in.y));
      Inc(Result, CheckPoint(Point(in.x-1,in.y));
      Inc(Result, CheckPoint(Point(in.x,in.y+1));
      Inc(Result, CheckPoint(Point(in.x,in.y-1));
   end;
end;

Diese exit; sind ja grässlich zimelich geil xD
Ich würde, der Lesbarkeit halber das negativieren:

Delphi-Quellcode:

function CheckPoint(in : TPoint):integer;
begin
   result := 0;

   if (not AusserhalbSpielfeld(in)) and (not IstInListe(in)) and (spielfeld[in.x, in.y] = belegt) then
   begin
     {...}
   end;
end;