Yorumları: 91
Konuları: 13
Kayıt Tarihi: 25-06-2017
Aktif Kullandığınız Delphi Sürümü:
Rep Puanı: 334 Acemi
Merhabalar
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.
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

- 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.
Yorumları: 1.070
Konuları: 46
Kayıt Tarihi: 24-07-2016
Aktif Kullandığınız Delphi Sürümü:
Rep Puanı: 3.109 Uzman
12-11-2024, Saat: 10:20
(Son Düzenleme: 12-11-2024, Saat: 10:37, Düzenleyen: engerex.)
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ı.
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.
Yorumları: 1.902
Konuları: 23
Kayıt Tarihi: 05-08-2016
Aktif Kullandığınız Delphi Sürümü:
Rep Puanı: 21.290 Üstad
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.
Saygılarımla
Muharrem ARMAN
Yorumları: 1.070
Konuları: 46
Kayıt Tarihi: 24-07-2016
Aktif Kullandığınız Delphi Sürümü:
Rep Puanı: 3.109 Uzman
@ 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.)
Yorumları: 91
Konuları: 13
Kayıt Tarihi: 25-06-2017
Aktif Kullandığınız Delphi Sürümü:
Rep Puanı: 334 Acemi
12-11-2024, Saat: 22:16
(Son Düzenleme: 12-11-2024, Saat: 22:22, Düzenleyen: berk06.)
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  İ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.

ChatGPT ile zar zor oluşturuldu
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.
Yorumları: 1.070
Konuları: 46
Kayıt Tarihi: 24-07-2016
Aktif Kullandığınız Delphi Sürümü:
Rep Puanı: 3.109 Uzman
13-11-2024, Saat: 08:58
(Son Düzenleme: 13-11-2024, Saat: 08:59, Düzenleyen: engerex.)
Mevzu YZ ise:
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.
|