Delphi Can
FMX ile koordinat bazlı yol bulma(Path Finding) - Baskı Önizleme

+- Delphi Can (https://www.delphican.com)
+-- Forum: Delphi (https://www.delphican.com/forumdisplay.php?fid=3)
+--- Forum: Mobil Platform - FireMonkey (FMX) (https://www.delphican.com/forumdisplay.php?fid=7)
+--- Konu Başlığı: FMX ile koordinat bazlı yol bulma(Path Finding) (/showthread.php?tid=7929)



FMX ile koordinat bazlı yol bulma(Path Finding) - berk06 - 12-11-2024

Merhabalar Smile

Uzun süredir nasıl yapılır nasıl olur diye araştırıyorum fakat bulduğum sonuçlar hep hüsran maalesef. Belki daha önce birileri ilgilenmiştir veya bir ışık tutar diye konu açmak istedim.

Yapmaya çalıştığım; kırmızı Rectangle objesini gri rectangle objelerine çarpmadan ve takılmadan istediğim x,y koordinatına götürmek. 
pathhh.png


Sırayla denediklerim;
  • AStar kütüphanelerinin hepsine baktım. Delphi/Pascal ile örnekler çok eski ve hep TGrid üzerine kurulmuş(Ben direkt form üzerinden x,y olarak yapmak istiyorum). Güncel değiller.
  • ChatGPT ve Gemini ye sorarak yapılar oluşturdum fakat çarpışma ve yolu bulma konusunda başarısız. Hesaplamalar çok yavaş doğal olarak Smile
  • Umudumu kaybedip kendim TList<node> şeklinde yapılar kurdum ve oluşturduğum haritaya node koordinatlarını elle eklemeye çalıştım. En yakın node üzerinden hareket ettirdim objemi. Fakat hareket edebilen objelerin olduğu bir yapıda her şey dinamik olacağı için bu fikir çöp oldu.



FMX ile koordinat bazlı yol bulma(Path Finding) - engerex - 12-11-2024

Bu işin hali hazırda mutlaka belli başlı mantık ile yapılan yolları vardır. Açıkçası bunları bilmiyorum. Ancak bazı sistemler için hesaplamalar tersten yapılıyor diye biliyorum.

Sıfırdan bir çözüm üretmeye çalışsa idim;
Formdaki koordinatları değişkenlere atar burada işlem yapardım.
Eğer şekiller kare ve dikdörtgen ise bunların merkez konumlarını alırdım. karelerin merkezi nokta, dikdörtgenler ise çizgi şeklinde olurdu.
İlk koordinattan hedef koordinattan bir çizgi çizdim ve çizgi aşağı ve sol yöne. Bu yöne gider ve çarptığı yeri not alırım. Şu koordinatta çarptı, sonrasında şu yöne gidildi. Tekrar konuma gelindiğinde tekrar aynı yöne gidilmesin. (çarptığı yer salında 2 numara olacaktı, 1.5 diye düşünebilirsin. Grafikte yazmamışım.)
2 numaralı noktada yine çarptı. Diğer yön 2 den 3'e giderken her adımda (diyelim 1 piksel) aşağı yöne hareket mümkün mü kontrol edilir. 3 nolu köşede aşağıya gidilebiliyor.
gri çizgiler konumdan hedefe çizgiler,
sarı deneme yanılma ile gidilen yollar.
mavi hedefe ulaştıkan sonra fazalık yolların kısaltılması.


image.png


Bu arada yukarıda şöyle bir şey demiştim "Eğer şekiller kare ve dikdörtgen ise bunların merkez konumlarını alırdım. karelerin merkezi nokta, dikdörtgenler ise çizgi şeklinde olurdu."
Bunu şöyle hayata geçirirdim. Kareler nokta, dikdörtgenler çizgi ise; mevcut konumdan bitiş konumuna bir çizgi çizer, bu çizginin başka çizgi ile kesişimi var ise o noktada başka yöne yönelirim. 1 numaralı çizgi yatay uzun çizgi (esasında dikdörtgen) ile kesişti ise esişen noktaya ışınlanırsın. Çok hızlı ilerledik. yatay çizginin kesiştiğimiz noktadan her iki ucuna uzaklığımızı bulur ve o uzaklığa ışınlanırız. Yol kapalı ise diğer yöne gideriz. gibi gibi.


FMX ile koordinat bazlı yol bulma(Path Finding) - mrmarman - 12-11-2024

Gezen nesne kare verildiği için konusu edilmemiş ancak en boy farklı bir nesne olsaydı başka bir unsuru daha dikkate almak gerekir.

Döndürülebilir özellik var mı konusu proje sahibine sorulmalıdır. 

Bu nesne otonom bir araç ve/veya taşıyıcı ise de dönüş manevra alanı da hesaba katılması için planlama yapılma gereğidir.

Bunları neden yazdım, çözümler yeni sorular nedeniyle sıkıntı doğurabilir veya çöpe de gidebilir. Öngörü kullanıp sorular çoğaltılırsa daha verimli çözümler bulunacaktır.


FMX ile koordinat bazlı yol bulma(Path Finding) - engerex - 12-11-2024

@mrmarman
Alıntı:Gezen nesne kare verildiği için konusu edilmemiş ancak en boy farklı bir nesne olsaydı başka bir unsuru daha dikkate almak gerekir.

Şekilleri nokta veya çizgiye dönüşümünden sonra dikdörtgen bilgilerini not almak tekrar dikdörtgene dönüşümü sağlıyor. Ancak siz söyleyince farkettim. Kullanımda gereksiz dönüşümler ve tutarsızlıklar var. 
 Şekillerin varolan çizgileri ile çalışmaları tespit etmek daha uygun görünüyor. (Görüntü son söylediğime göre çizilmişti.)


FMX ile koordinat bazlı yol bulma(Path Finding) - berk06 - 12-11-2024

Güzel cevaplarınız için teşekkür ederim.

Yol bulma algoritmalarının çoğu @engerex fikir yürüttüğünüz şekliyle çalışıyor. Benzer bir yapıyı aşağıya bırakıyorum. Biraz da olsa bir başarı sağladım.


@mrmarman daha ilk adımı başarılı atamadığım için "ilk adımım doğru mu" sorusunu soramadım. Sorduğunuz sorulara sıra gelemedi Smile İhtiyaca göre şekillenecek bir başlangıç lazım dediğiniz gibi. Amacım sadece objeleri bir birine çarpmadan oradan oraya sürüklemek şimdilik.


pathf.gif
ChatGPT ile zar zor oluşturuldu Smile 
unit PathfindingUnit;

interface

uses
 System.SysUtils, System.Types, System.Generics.Collections, System.Classes, FMX.Objects, FMX.Graphics,
 System.UITypes;

type
 TNode = record
   X, Y: Integer;
   GCost, HCost, FCost: Integer;
   ParentX, ParentY: Integer;
   constructor Create(aX, aY: Integer);
 end;

 TPathfinding = class
 private
   FCharacter: TRectangle;
   FTarget: TPoint;
   FObstacles: TArray<TRectangle>;
   FPathList: TStringList;
   FGridSize: Integer;

   procedure OptimizePath;
   function GetValidNeighbors(CurrentNode: TNode): TArray<TNode>;
   function IsCollision: Boolean;
 public
   constructor Create(Character: TRectangle; Target: TPoint; Obstacles: TArray<TRectangle>; GridSize: Integer = 20);
   destructor Destroy; override;
   procedure FindPath;
   property PathList: TStringList read FPathList;      function IsWalkable(X, Y: Integer): Boolean;
 end;

implementation

{ TNode }

constructor TNode.Create(aX, aY: Integer);
begin
 X := aX;
 Y := aY;
 GCost := 0;
 HCost := 0;
 FCost := 0;
 ParentX := -1;
 ParentY := -1;
end;

{ TPathfinding }

constructor TPathfinding.Create(Character: TRectangle; Target: TPoint; Obstacles: TArray<TRectangle>; GridSize: Integer);
begin
 FCharacter := Character;
 FTarget := Target;
 FObstacles := Copy(Obstacles, 0, Length(Obstacles));
 FPathList := TStringList.Create;
 FGridSize := GridSize;
end;

destructor TPathfinding.Destroy;
begin
 FPathList.Free;
 inherited;
end;

function TPathfinding.GetValidNeighbors(CurrentNode: TNode): TArray<TNode>;
var
 Neighbors: TList<TNode>;
 dx, dy: Integer;
 Neighbor: TNode;
begin
 Neighbors := TList<TNode>.Create;
 try
   for dx := -1 to 1 do
     for dy := -1 to 1 do
     begin
       if (dx = 0) and (dy = 0) then
         Continue;
       // Diyagonal hareketi kontrol et, engellerin kenarlarından geçmemesini sağlar
       if (Abs(dx) + Abs(dy) = 2) and (not IsWalkable(CurrentNode.X + dx, CurrentNode.Y) or not IsWalkable(CurrentNode.X, CurrentNode.Y + dy)) then
         Continue;

       Neighbor := TNode.Create(CurrentNode.X + dx, CurrentNode.Y + dy);
       if IsWalkable(Neighbor.X * FGridSize, Neighbor.Y * FGridSize) then
         Neighbors.Add(Neighbor);
     end;
   Result := Neighbors.ToArray;
 finally
   Neighbors.Free;
 end;
end;

function GetMinFCostNode(OpenList: TDictionary<Integer, TNode>): TNode;
var
 Node: TNode;
 MinNode: TNode;
 MinCost: Integer;
begin
 MinCost := MaxInt;
 for Node in OpenList.Values do
 begin
   if Node.FCost < MinCost then
   begin
     MinCost := Node.FCost;
     MinNode := Node;
   end;
 end;
 Result := MinNode;
end;


function CheckBoundryCollision( R1, R2 : TRect; pR : PRect = nil; OffSetY : LongInt = 0; OffSetX : LongInt = 0): boolean;
begin
 if( pR <> nil ) then
  begin
   with( R1 ) do
    R1:=Rect( Left+OffSetX, Top+OffSetY, Right-(OffSetX * 2), Bottom-(OffSetY * 2));
   with( R2 ) do
    R2:=Rect( Left+OffSetX, Top+OffSetY, Right-(OffSetX * 2), Bottom-(OffSetY * 2));

   Result:=IntersectRect( pR^, R1, R2 );
  end
 else begin
       Result:=( NOT ((R1.Bottom - (OffSetY * 2) < R2.Top + OffSetY)
         or(R1.Top + OffSetY > R2.Bottom - (OffSetY * 2))
          or( R1.Right - (OffSetX * 2) < R2.Left + OffSetX)
           or( R1.Left + OffSetX > R2.Right - (OffSetX * 2))));
      end;
end;

procedure TPathfinding.FindPath;
var
 StartNode, EndNode: TNode;
 OpenList, ClosedList: TDictionary<Integer, TNode>;
 CurrentNode, Neighbor: TNode;
 GCost, HCost, FCost: Integer;
 PathFound: Boolean;

 function CalculateHCost(Node1, Node2: TNode): Integer;
 begin
   Result := Abs(Node1.X - Node2.X) + Abs(Node1.Y - Node2.Y);  // Manhattan mesafesi
 end;
begin

 if IsCollision = True then
 begin
   FCharacter.Fill.Color := TAlphaColorRec.Red;
   Exit;
 end;

 FCharacter.Fill.Color := TAlphaColorRec.Lightgreen;
 StartNode := TNode.Create(Round(FCharacter.Position.X / FGridSize), Round(FCharacter.Position.Y / FGridSize));
 EndNode := TNode.Create(Round(FTarget.X / FGridSize), Round(FTarget.Y / FGridSize));

 OpenList := TDictionary<Integer, TNode>.Create;
 ClosedList := TDictionary<Integer, TNode>.Create;
 PathFound := False;
 try
   OpenList.Add(StartNode.X * 10000 + StartNode.Y, StartNode);

   while OpenList.Count > 0 do
   begin
     CurrentNode := GetMinFCostNode(OpenList);

     OpenList.Remove(CurrentNode.X * 10000 + CurrentNode.Y);
     ClosedList.Add(CurrentNode.X * 10000 + CurrentNode.Y, CurrentNode);

     // Hedefe ulaşıldıysa yolu oluştur
     if (CurrentNode.X = EndNode.X) and (CurrentNode.Y = EndNode.Y) then
     begin
       PathFound := True;
       while (CurrentNode.ParentX <> -1) and (CurrentNode.ParentY <> -1) do
       begin
         FPathList.Add(Format('%d,%d', [CurrentNode.X * FGridSize, CurrentNode.Y * FGridSize]));
         CurrentNode := ClosedList[CurrentNode.ParentX * 10000 + CurrentNode.ParentY];
       end;
       FPathList.Add(Format('%d,%d', [StartNode.X * FGridSize, StartNode.Y * FGridSize]));
       OptimizePath;
       Break;
     end;

     // Geçerli düğümün komşularını incele
     for Neighbor in GetValidNeighbors(CurrentNode) do
     begin
       // Çarpışmayı kontrol et
       if ClosedList.ContainsKey(Neighbor.X * 10000 + Neighbor.Y) or not IsWalkable(Neighbor.X * FGridSize, Neighbor.Y * FGridSize) then
         Continue;

       GCost := CurrentNode.GCost + 1;
       HCost := CalculateHCost(Neighbor, EndNode);
       FCost := GCost + HCost;

       var TempNeighbor := Neighbor;
       if not OpenList.ContainsKey(TempNeighbor.X * 10000 + TempNeighbor.Y) then
       begin
         TempNeighbor.GCost := GCost;
         TempNeighbor.HCost := HCost;
         TempNeighbor.FCost := FCost;
         TempNeighbor.ParentX := CurrentNode.X;
         TempNeighbor.ParentY := CurrentNode.Y;
         OpenList.Add(TempNeighbor.X * 10000 + TempNeighbor.Y, TempNeighbor);
       end;
     end;
   end;

   // Eğer yol bulunamadıysa uyarı göster
   if not PathFound then
     FCharacter.Fill.Color := TAlphaColorRec.Red;
 finally
   OpenList.Free;
   ClosedList.Free;
 end;
end;

function TPathfinding.IsCollision: Boolean;
var
 tmpRect: TRectangle;
begin
 Result := False;
 tmpRect := TRectangle.Create(nil);
 tmpRect.Height :=  FCharacter.Height;
 tmpRect.Width  :=  FCharacter.Width;
 tmpRect.Position.X := FTarget.X;
 tmpRect.Position.Y := FTarget.Y;

 for var Obstacle in FObstacles do
 begin
   if CheckBoundryCollision(tmpRect.BoundsRect.Round,Obstacle.BoundsRect.Round) = True then
   begin
     Result := True;
     Break;
   end;
 end;

 FreeAndNil(tmpRect);
end;

function TPathfinding.IsWalkable(X, Y: Integer): Boolean;
var
 CharRect, ObstacleRect: TRectF;
begin
 CharRect := TRectF.Create(X, Y, X + FCharacter.Width, Y + FCharacter.Height);
 Result := True;

 for var Obstacle in FObstacles do
 begin
   ObstacleRect := TRectF.Create(Obstacle.Position.X, Obstacle.Position.Y, Obstacle.Position.X + Obstacle.Width, Obstacle.Position.Y + Obstacle.Height);
   if CharRect.IntersectsWith(ObstacleRect) then
   begin
     Result := False;
     Break;
   end;
 end;
end;

procedure TPathfinding.OptimizePath;
var
 i: Integer;
 CurrDir, NextDir: TPoint;
begin
 i := 0;
 while i < FPathList.Count - 2 do
 begin
   var Point1 := TPoint.Create(StrToInt(FPathList[i].Split([','])[0]), StrToInt(FPathList[i].Split([','])[1]));
   var Point2 := TPoint.Create(StrToInt(FPathList[i + 1].Split([','])[0]), StrToInt(FPathList[i + 1].Split([','])[1]));
   var Point3 := TPoint.Create(StrToInt(FPathList[i + 2].Split([','])[0]), StrToInt(FPathList[i + 2].Split([','])[1]));

   CurrDir := Point2 - Point1;
   NextDir := Point3 - Point2;

   if (CurrDir.X = NextDir.X) and (CurrDir.Y = NextDir.Y) then
     FPathList.Delete(i + 1)
   else
     Inc(i);
 end;
end;

end.

Kendimce kullanımı;
procedure TForm1.Layout1MouseDown(Sender: TObject; Button: TMouseButton;
 Shift: TShiftState; X, Y: Single);
var
 Pathfinding: TPathfinding;
 Obstacles: TArray<TRectangle>;
 i: integer;
 pdata: TPathData;
begin
 // Engelleri diziye ekleyin
 pa.Stop;
 SetLength(Obstacles, 3);
 Obstacles[0] := Rectangle4;
 Obstacles[1] := Rectangle2;
 Obstacles[2] := Rectangle3;
 memo1.Lines.Clear;
 Layout1.Repaint;
 Application.ProcessMessages;

 Pathfinding := TPathfinding.Create(Character, Point(Round(X), Round(Y)), Obstacles);
 try

   Pathfinding.FindPath;

   //for var i := 0 to Pathfinding.PathList.Count - 1 do
   for i := Pathfinding.PathList.Count - 1 downto 0 do
     Memo1.Lines.Add(Pathfinding.PathList[i]); // Koordinatları gösterme
 finally
   Pathfinding.Free;
 end;

 pdata := TPathData.Create;
 for i := 0 to Memo1.Lines.Count-1 do
 begin
   if Memo1.Lines.Strings[i] <> '' then
   begin
     if i = 0 then pdata.MoveTo(PointF(Round(memo1.Lines.Strings[i].Split([','])[0].ToSingle),Round(memo1.Lines.Strings[i].Split([','])[1].ToSingle)));
     pdata.LineTo(PointF(Round(memo1.Lines.Strings[i].Split([','])[0].ToSingle),Round(memo1.Lines.Strings[i].Split([','])[1].ToSingle)));

   end;
 end;
 pdata.ClosePath;
 Layout1.Canvas.BeginScene;
 try
   Layout1.Canvas.Stroke.Color := TAlphaColorRec.Red;
   Layout1.Canvas.Stroke.Thickness := 1;
   Layout1.Canvas.Stroke.Dash := TStrokeDash.Solid;
   Layout1.Canvas.DrawPath(pdata,100);
 finally
   Layout1.Canvas.EndScene;
 end;

 pdata.Free;
 if Memo1.Lines.Count <= 0 then
   exit;
 ipath := 0;
 pa.StartValue.X := Character.Position.X;
 pa.StartValue.Y := Character.Position.Y;
 pa.StopValue.X := Character.Position.X;
 pa.StopValue.Y := Character.Position.Y;
 pa.Start;
end;

pa komponenti FGX eklenti seti içerisindeki PositionAnimation. 
GitHub - theilgaz/FGX: This is a repacked FGX Components for Delphi 10.4 Sydney. This pack is compatible with Delphi 10.3 Rio and earlier versions.


FMX ile koordinat bazlı yol bulma(Path Finding) - engerex - 13-11-2024

Mevzu YZ ise:

image.png

unit MainUnit;

interface

uses
 System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
 FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Objects,
 System.Math, System.Generics.Collections;

type
 TNode = class
   X, Y: Single;
   G, H, F: Single;
   Parent: TNode;
   constructor Create(AX, AY: Single);
 end;

 TMainForm = class(TForm)
   Timer1: TTimer;
   procedure FormCreate(Sender: TObject);
   procedure FormMouseDown(Sender: TObject; Button: TMouseButton;
     Shift: TShiftState; X, Y: Single);
   procedure Timer1Timer(Sender: TObject);
   procedure FormDestroy(Sender: TObject);
 private
   FPlayer: TRectangle;
   FWalls: array of TRectangle;
   FPath: TList<TPointF>;
   FCurrentPathIndex: Integer;
   FMoving: Boolean;
   procedure CreateMaze;
   function CheckCollision(ARect: TRectangle; X, Y: Single): Boolean;
   function FindPath(StartX, StartY, EndX, EndY: Single): TList<TPointF>;
   function GetNeighbors(Node: TNode; EndX, EndY: Single): TList<TNode>;
   function CalculateHeuristic(X1, Y1, X2, Y2: Single): Single;
 public
   { Public declarations }
 end;

var
 MainForm: TMainForm;

implementation

{$R *.fmx}

constructor TNode.Create(AX, AY: Single);
begin
 inherited Create;
 X := AX;
 Y := AY;
 G := 0;
 H := 0;
 F := 0;
 Parent := nil;
end;

procedure TMainForm.FormCreate(Sender: TObject);
begin
 Randomize;

 Width := 800;
 Height := 600;

 FPlayer := TRectangle.Create(Self);
 with FPlayer do
 begin
   Parent := Self;
   Width := 20;
   Height := 20;
   Position.X := 50;
   Position.Y := 50;
   Fill.Color := TAlphaColors.Blue;
   Stroke.Kind := TBrushKind.None;
 end;

 Timer1 := TTimer.Create(Self);
 Timer1.Interval := 16;
 Timer1.OnTimer := Timer1Timer;
 Timer1.Enabled := False;

 FPath := TList<TPointF>.Create;

 OnMouseDown := FormMouseDown;
 OnDestroy := FormDestroy;

 CreateMaze;
end;

procedure TMainForm.FormDestroy(Sender: TObject);
var
 i: Integer;
begin
 for i := 0 to Length(FWalls) - 1 do
 begin
   if Assigned(FWalls[i]) then
     FWalls[i].Free;
 end;
 SetLength(FWalls, 0);

 if Assigned(FPath) then
   FPath.Free;

 if Assigned(FPlayer) then
   FPlayer.Free;
end;

function TMainForm.FindPath(StartX, StartY, EndX, EndY: Single): TList<TPointF>;
var
 OpenList: TList<TNode>;
 ClosedList: TList<TNode>;
 CurrentNode, Neighbor: TNode;
 Path: TList<TPointF>;
 NodeToRemove: TNode;
 i: Integer;
begin
 Path := TList<TPointF>.Create;
 OpenList := TList<TNode>.Create;
 ClosedList := TList<TNode>.Create;
 try
   // Başlangıç düğümünü ekle
   CurrentNode := TNode.Create(StartX, StartY);
   OpenList.Add(CurrentNode);

   while OpenList.Count > 0 do
   begin
     // En düşük F değerine sahip düğümü bul
     CurrentNode := OpenList[0];
     for i := 1 to OpenList.Count - 1 do
       if OpenList[i].F < CurrentNode.F then
         CurrentNode := OpenList[i];

     // Hedef noktaya ulaştık mı?
     if (Abs(CurrentNode.X - EndX) < 20) and (Abs(CurrentNode.Y - EndY) < 20) then
     begin
       // Yolu geri izle
       while CurrentNode <> nil do
       begin
         Path.Insert(0, TPointF.Create(CurrentNode.X, CurrentNode.Y));
         CurrentNode := CurrentNode.Parent;
       end;
       Break;
     end;

     // Mevcut düğümü kapalı listeye taşı
     OpenList.Remove(CurrentNode);
     ClosedList.Add(CurrentNode);

     // Komşu düğümleri kontrol et
     var Neighbors := GetNeighbors(CurrentNode, EndX, EndY);
     try
       for Neighbor in Neighbors do
       begin
         // Komşu düğüm kapalı listede mi?
         var InClosedList := False;
         for var ClosedNode in ClosedList do
         begin
           if (Abs(ClosedNode.X - Neighbor.X) < 1) and (Abs(ClosedNode.Y - Neighbor.Y) < 1) then
           begin
             InClosedList := True;
             Break;
           end;
         end;

         if InClosedList then
           Continue;

         // G değerini hesapla
         var TentativeG := CurrentNode.G + Sqrt(
           Sqr(CurrentNode.X - Neighbor.X) + Sqr(CurrentNode.Y - Neighbor.Y)
         );

         // Komşu düğüm açık listede var mı?
         var InOpenList := False;
         for var OpenNode in OpenList do
         begin
           if (Abs(OpenNode.X - Neighbor.X) < 1) and (Abs(OpenNode.Y - Neighbor.Y) < 1) then
           begin
             InOpenList := True;
             if TentativeG < OpenNode.G then
             begin
               OpenNode.G := TentativeG;
               OpenNode.F := OpenNode.G + OpenNode.H;
               OpenNode.Parent := CurrentNode;
             end;
             Break;
           end;
         end;

         if not InOpenList then
         begin
           Neighbor.G := TentativeG;
           Neighbor.H := CalculateHeuristic(Neighbor.X, Neighbor.Y, EndX, EndY);
           Neighbor.F := Neighbor.G + Neighbor.H;
           Neighbor.Parent := CurrentNode;
           OpenList.Add(Neighbor);
         end;
       end;
     finally
       Neighbors.Free;
     end;
   end;
 finally
   // Bellek temizliği
   for i := 0 to OpenList.Count - 1 do
     OpenList[i].Free;
   for i := 0 to ClosedList.Count - 1 do
     ClosedList[i].Free;
   OpenList.Free;
   ClosedList.Free;
 end;

 Result := Path;
end;

function TMainForm.GetNeighbors(Node: TNode; EndX, EndY: Single): TList<TNode>;
const
 STEP_SIZE = 20;
 DIRECTIONS: array[0..7] of TPointF = (
   (X:  1; Y:  0),  // Sağ
   (X:  1; Y:  1),  // Sağ-alt
   (X:  0; Y:  1),  // Alt
   (X: -1; Y:  1),  // Sol-alt
   (X: -1; Y:  0),  // Sol
   (X: -1; Y: -1),  // Sol-üst
   (X:  0; Y: -1),  // Üst
   (X:  1; Y: -1)   // Sağ-üst
 );
var
 NewX, NewY: Single;
 i: Integer;
begin
 Result := TList<TNode>.Create;

 for i := 0 to High(DIRECTIONS) do
 begin
   NewX := Node.X + DIRECTIONS[i].X * STEP_SIZE;
   NewY := Node.Y + DIRECTIONS[i].Y * STEP_SIZE;

   // Sınırlar içinde mi?
   if (NewX >= 0) and (NewX <= Width - FPlayer.Width) and
      (NewY >= 0) and (NewY <= Height - FPlayer.Height) then
   begin
     // Engellere çarpıyor mu?
     if not CheckCollision(nil, NewX, NewY) then
       Result.Add(TNode.Create(NewX, NewY));
   end;
 end;
end;

function TMainForm.CalculateHeuristic(X1, Y1, X2, Y2: Single): Single;
begin
 Result := Sqrt(Sqr(X2 - X1) + Sqr(Y2 - Y1));
end;

procedure TMainForm.FormMouseDown(Sender: TObject; Button: TMouseButton;
 Shift: TShiftState; X, Y: Single);
begin
 // Eski yolu temizle
 FPath.Clear;

 // Yeni yolu hesapla
 var NewPath := FindPath(FPlayer.Position.X, FPlayer.Position.Y, X, Y);
 try
   FPath.AddRange(NewPath);
 finally
   NewPath.Free;
 end;

 FCurrentPathIndex := 0;
 FMoving := True;
 Timer1.Enabled := True;
end;

procedure TMainForm.Timer1Timer(Sender: TObject);
const
 SPEED = 5;
var
 TargetPoint: TPointF;
 DX, DY, Distance: Single;
begin
 if not FMoving or (FPath.Count = 0) or (FCurrentPathIndex >= FPath.Count) then
 begin
   Timer1.Enabled := False;
   FMoving := False;
   Exit;
 end;

 TargetPoint := FPath[FCurrentPathIndex];

 DX := TargetPoint.X - FPlayer.Position.X;
 DY := TargetPoint.Y - FPlayer.Position.Y;
 Distance := Sqrt(DX * DX + DY * DY);

 if Distance < SPEED then
 begin
   Inc(FCurrentPathIndex);
   if FCurrentPathIndex >= FPath.Count then
   begin
     FMoving := False;
     Exit;
   end;
 end
 else
 begin
   DX := DX / Distance * SPEED;
   DY := DY / Distance * SPEED;
   FPlayer.Position.X := FPlayer.Position.X + DX;
   FPlayer.Position.Y := FPlayer.Position.Y + DY;
 end;
end;

procedure TMainForm.CreateMaze;
const
 WALL_COUNT = 20;
 MIN_WALL_SIZE = 40;
 MAX_WALL_SIZE = 120;
 SAFE_DISTANCE = 100;
var
 i: Integer;
 NewX, NewY: Single;
 Attempts: Integer;
 ValidPosition: Boolean;
begin
 SetLength(FWalls, WALL_COUNT);

 for i := 0 to WALL_COUNT - 1 do
 begin
   FWalls[i] := TRectangle.Create(Self);
   with FWalls[i] do
   begin
     Parent := Self;
     Width := RandomRange(MIN_WALL_SIZE, MAX_WALL_SIZE);
     Height := RandomRange(MIN_WALL_SIZE, MAX_WALL_SIZE);
     Fill.Color := TAlphaColors.Red;
     Stroke.Kind := TBrushKind.None;

     Attempts := 0;
     repeat
       ValidPosition := True;
       NewX := RandomRange(0, Self.Width - Round(Width));
       NewY := RandomRange(0, Self.Height - Round(Height));

       if (Abs(NewX - FPlayer.Position.X) < SAFE_DISTANCE) and
          (Abs(NewY - FPlayer.Position.Y) < SAFE_DISTANCE) then
       begin
         ValidPosition := False;
       end;

       if ValidPosition then
       begin
         for var j := 0 to i - 1 do
         begin
           if Assigned(FWalls[j]) then
           begin
             if (Abs(NewX - FWalls[j].Position.X) < MIN_WALL_SIZE) and
                (Abs(NewY - FWalls[j].Position.Y) < MIN_WALL_SIZE) then
             begin
               ValidPosition := False;
               Break;
             end;
           end;
         end;
       end;

       Inc(Attempts);
       if Attempts > 100 then
       begin
         Width := RandomRange(MIN_WALL_SIZE div 2, MAX_WALL_SIZE div 2);
         Height := RandomRange(MIN_WALL_SIZE div 2, MAX_WALL_SIZE div 2);
         Attempts := 0;
       end;

     until ValidPosition or (Attempts > 200);

     Position.X := NewX;
     Position.Y := NewY;
   end;
 end;
end;

function TMainForm.CheckCollision(ARect: TRectangle; X, Y: Single): Boolean;
var
 R1, R2: TRectF;
begin
 Result := False;

 R1 := TRectF.Create(X, Y, X + FPlayer.Width, Y + FPlayer.Height);

 for var Wall in FWalls do
 begin
   if not Assigned(Wall) then Continue;
   if Wall = ARect then Continue;

   R2 := TRectF.Create(Wall.Position.X, Wall.Position.Y,
                       Wall.Position.X + Wall.Width,
                       Wall.Position.Y + Wall.Height);

   if R1.IntersectsWith(R2) then
     Exit(True);
 end;

 Result := (X < 0) or (Y < 0) or
           (X + FPlayer.Width > Width) or
           (Y + FPlayer.Height > Height);
end;

end.