Rechtecke überlagern sich beim zufälligen erstellen ?

[mimi]

Hallo,
ich habe es mit meinem eignen code nicht und mit einem code aus disem forum auch nicht hinbekommen.
Ich möchte gerne das meine bilder zufällig auf ein TBitMap verteielt werden und dabei ist zu berücksichtigen:
Es darf kein andres Objekt auf der Position sein
Und es darf nicht auserhalb des angeben Rechteckes sein.
ich habe hier die proceduren und funktionen die dafür verantwortlich sind rein kopiert:

Delphi-Quellcode:

// Diese hier habe ich aus dem forum
function RectIntersect(A, B: TRect; Offset: Integer): Boolean;
begin
  result := not((A.Right + Offset  <= B.Left)   or
                (A.Bottom + Offset <= B.Top)    or
                (A.Top - Offset    >= B.Bottom) or
                (A.Left - Offset   >= B.Right));
end;
// -----------------------

function TForm1.Kollision(rect:TRect):Boolean;
var
  i:Integer;
  r1:TRect;
begin
  result:=False;           
  for i := 0 to High(Items) do begin
    r1.Left:=Items[i].x; r1.Top:=Items[i].y;
    r1.Right:=Items[i].w; r1.Bottom:=Items[i].h;  
    if RectIntersect(r1,rect, 100) then begin
      result:=True;
     // break;
    end;
  end;
end;
// hier kommt die anwendung 
function TForm1.Zufall(px,py,w,h,index:Integer):TPoint;
var
  x,y,z:Integer;
  i,r:Boolean;
begin

  x:=px; y:=py; z:=0;
//  px:=px*w; py:=py*h;

  i:=CheckCollision(px,py,w,h,index);//CheckCollision(x*w,y*h,w,h,index);
  Label3.Caption:=BoolToStr(i,True);

  if (i = False) or (x < 0) or (y <0) or (x > 640) or (y >240) then begin
    repeat
      x:=random(640-w);
      y:=random(280-h);
      inc(z);
      r:=CheckCollision(x,y,w,h,index);
    until (r = False) or (z = 5);
  end;
  ListBox1.Items.Add(IntToStr(Index)+ '\'+ IntToStr(x) + '\' + IntToStr(y));
  result.X:=x;
  result.Y:=y;
end;
// und hier noch mal meine eigne:
function TForm1.GetItemIndex(px,py,pw,ph,Index:Integer):Integer;
var
  i:Integer;
  t:Integer;
  g:TRect;
begin
  ListBox2.items.Clear;
  t:=-1;
  Label1.Caption:='';
  for i:=0 to HIGH(Items) do begin
    with Items[i] do begin
         ListBox2.Items.Add(IntTostr(x) + '\' + IntToStr(y));

      if (typ <> 4) and (typ <> 1) and (PlayerIndex <> i) then begin
//        if PtInRect(Rect(x,y,w,h),Point(px,py)) = True then begin
         if IntersectRect(g,rect(x,y,w,h),rect(px,py,pw,ph)) = True then begin
                 Label1.Caption:=InttoStr(x)+'\'+IntToStr(y) + '\'+ IntToStr(Random(4));
         //       if (px >=x) and ( py>=y) and (px <=x+pw) and (py <=y+ph)then begin
//        if (x >=px) and (y >=py) and (x <=px+pw) and (y <=py+ph) and (PlayerIndex <> i) then begin

          t:=i;
          break;
        end;
      end;
    end;
  end;
  result:=t;
end;

das problem dabei ist bei diesem code überlagen sich teilweise die Grafiken übereinander und ich weiß einfach nicht warum. Habe hier im forum gesucht letzte woche saß ich stunden vor diesem Problem, habe aber leider keine lösung gefunden !

[marabu]

Hallo Michael,

ich habe heute wohl schon zuviel Code gesehen, deshalb nur ein paar Anmerkungen:

• Windows kennt bereits eine Funktion IntersectRect().
• Soweit ich erkennen kann schmeißt du ein Bild auf die Fläche und wenn es eines der vorher dort drapierten Bilder überlappt, dann wirfst du nochmal. Nicht sehr effektiv. Jedes platzierte Bild bestimmt neue Freiflächen, die für ein kollisionsfreies Platzieren der restlichen Bilder geeignet oder ungeeignet sind.
  Ich würde anders vorgehen. Ich würde die Bilder so eng wie möglich aneinander schmiegen und zum Schluß jedes Bild auf einer radialen Achse um einen Zufallswert nach außen verschieben.

Freundliche Grüße vom marabu

[mimi]

die Windows Funktion verwende ich bereits !
Deine Idee ist nicht schlecht. Nur ich weiß immer noch nicht warum sich die Rechecke überlappen :(

[marabu]

Das könnte daran liegen, dass du in deiner Methode Kollision() die Vergleichsrechtecke falsch initialisierst:

Delphi-Quellcode:

// ...
  for i := 0 to High(Items) do 
  begin
    r1.Left := Items[i].x; 
    r1.Top := Items[i].y;
    r1.Right := Pred(Items[i].w + r1.Left); 
    r1.Bottom := Pred(Items[i].h + r1.Top); 
// ...

marabu

[tigerman33]

Hallo mimi,

dein Code ist ein bisschen unübersichtlich und es fehlen Teile (z.B. die Funktion CheckCollision) als dass man eine gesicherte Aussage machen kann.
Aber ich denke ein Grund dafür könnte sein, dass deine repeat..until Schleife, in der du ja versuchst, einen passenden ("freien") Punkt zu finden, insgesamt nur fünf mal durchlaufen wird. Wenn du danach in x und y Werte stehen hast, die eigentlich zu einer Kollision führen, liefert dir die Methode Zufall dennoch diese Werte zurück.

[mimi]

den wert 5 habe ich gewählt weil es egal ist wie oft die schleife ausgefürht wird.
Mache ich dies nicht hängt sich das Programm auf !
hier die funktion CheckCollision:

Delphi-Quellcode:

function TForm1.CheckCollision(px,py,w,h,Index:Integer):Boolean;
var
  o:Boolean;
  z:Boolean;
begin
  o:=False; z:=False;

  z:=Kollision(rect(px,py,w,h));//GetItemIndex(px,py,w,h,index);
 // Label1.Caption:=IntToStr(py);
  Label3.Caption:='';
  if (px > 0) and (px < 640-w) and (py >0) and ((Items[index].isPlayer = True) and (py < 480) or (Items[index].isPlayer = False) and (py < 280))then begin
    o:=True;
  end;
  if (z = True) then begin
    Label3.Caption:=IntToStr(px) + '\' + IntToStr(py);
    o:=True
  end
  else begin
//    Label3.Caption:=intToStr(z) + '*';
    o:=False;
  end;

//  else
//BoolToStr(o,True) + '\' + IntToStr(z) + '\' + InttoStr(Index)+'\'+ intToStr(high(Items))
  result:=o;
end;

Ich persönlich finde meinen Code nicht unübersichtlich. Da ich mich inzwischen mich an diesen QullcodeStyle gewöhnt habe *G*.
Nagut dies ist auch nur als "einfacher Test" gedacht gewesen für eine Grafik Lib. Normalerweise schreibe ich auch etwas übersichtlicher und mit weniger sinloser kometaren *G*....

[tigerman33]

Endlosschleife spricht ja sehr dafür, dass CheckCollision eine Tautologie (also immer wahr) ist. Der Grund dafür könnte in dieser Zeile liegen:

Delphi-Quellcode:

if ... and ((Items[index].isPlayer = True) and (py < 480) or (Items[index].isPlayer = False) and (py < 280))

Ich bin mir nicht sicher wie der Compiler die booleschen Operatoren abarbeitet. Konvention ist ja, dass das "Und" stärker bindet als das "Oder", aber ich meine mich erinnern zu können, dass Delphi die beiden gleichwertig behandelt ("wer zuerst kommt, mahlt zuerst). Probier mal eine andere Klammerung:

Delphi-Quellcode:

if ... and (((Items[index].isPlayer = True) and (py < 480)) or ((Items[index].isPlayer = False) and (py < 280)))

Hilft das?

PS: Mit unübersichtlich meinte ich nicht so sehr den Code an sich, sondern eher die, ähm, minimalistische Variablenbenennung. :zwinker:

[mimi]

habe ich geändert überlappen sich leider immer noch teielweise:

Delphi-Quellcode:

function TForm1.CheckCollision(px,py,w,h,Index:Integer):Boolean;
var
  o:Boolean;
  z:Boolean;
begin
  o:=False; z:=False;

  z:=Kollision(rect(px,py,w,h));//GetItemIndex(px,py,w,h,index);
 // Label1.Caption:=IntToStr(py);
  Label3.Caption:='';
  if (px > 0) and (px < 640-w) and (py >0) and (((Items[index].isPlayer = True) and (py < 480)) or ((Items[index].isPlayer = False) and (py < 280)))then begin
    o:=True;
  end;
  if (z = True) then begin
    Label3.Caption:=IntToStr(px) + '\' + IntToStr(py);
    o:=True
  end
  else begin
//    Label3.Caption:=intToStr(z) + '*';
    o:=False;
  end;

//  else
//BoolToStr(o,True) + '\' + IntToStr(z) + '\' + InttoStr(Index)+'\'+ intToStr(high(Items))
  result:=o;
end;

Ja die Variabeln bennung fällt mir irgenwie noch nach ca 6-8 Jahren delphi programmiren sehr schwer *G*. Weil ich finde meistens keine passenden Namen für die Funktion/Procedure/Variable/Klasse die kurtzt beschreibt wo für es da ist.

[mimi]

es muss doch ein grund geben warum das nicht funktioniert, oder etwa nicht ?

[Airblader]

Zur Codesache:

1. Kommentieren ;)
2. Auch if-Verschachtelungen lassen sich besser darstellen (über mehrere Zeilen verteilt)
3. Ein System zur Variablenbenennung machen. Ich benutze z.B. immer ein Prefix für den Typ der Variable ('b' für Boolean, 'i' für Integer, ...) und setze danach - großgeschrieben - den Namen, der z.T. auch systematisch ist. Bei Booleans z.B. oft mit "Is" beginnend.
Bei mir wäre dein 'z' beispielhaft 'bIsCollisioned' ;)

air