Entwickler-Ecke

Multimedia / Grafik - Wie mache ich eine KI (Pathfinding) im Spiel?


Pyr0cracker - So 22.06.03 15:12
Titel: Wie mache ich eine KI (Pathfinding) im Spiel?
Hallo,

ich mach grad ein Spiel mit isometrischer Sicht. Nun will ich die Spielfigur über die Landschaft steuern indem ich an eine Stelle klicke und die Figur dann dahin läuft. Eigentlich ist das nicht schwierig:

Delphi-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
 
if player.X < ziel_x then
  player.X := player.X + 2;

if player.X > ziel_x then
  player.X := player.X - 2;

if player.Y < ziel_y then
  player.Y := player.Y + 2;

if player.y > ziel_y then
  player.Y := player.Y - 2;

Nun habe ich aber ein Problem damit die Figur um eine Grafik herumlaufen zu lassen. Erst wollte ich es mit Array machen, aber das geht irdendwie auch nicht
(hier [http://www.lesta.de/dorian/Htmlseiten/meinesachen/array.zip] ist ein beispiel.) Irgendwie kann man da aber nur horizontal oder vertikal was anklicken, damit die Figur dahin geht.

Gibts nicht noch eine andere/einfachere Möglichkeit um das zu realisieren?

Danke für alle Antworten,

Moderiert von user profile iconTino: Code- durch Delphi-Tags ersetzt.


Simon Joker - Di 24.06.03 14:26
Hi Pyr0cracker

Mach diesen Coade in deine Wegfindungs Procedure:

Delphi-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
 
procedure WegFind;
var
  DistX, DistY :integer;
begin
  pos_x := round(player.x) div 50;
  pos_y := round(player.y) div 50;
  DistX:=Ziel_X-Pos_X;
  DistY:=Ziel_Y-Pos_Y;
  if abs(DistX)>abs(DistY) then begin
    if DistX>0 then
      Player.X:=Player.X+1;
    if DistX<0 then
      Player.X:=Player.X-1;
  end;
  if abs(DistX)>abs(DistY) then begin
    if DistY>0 then
      Player.Y:=Player.Y+1;
    if DistY<0 then
      Player.Y:=Player.Y-1;
  end;
  if abs(DistX)=abs(DistY) then begin
    if DistX>0 then
      Player.X:=Player.X+1;
    if DistX<0 then
      Player.X:=Player.X-1;
    if DistY>0 then
      Player.Y:=Player.Y+1;
    if DistY<0 then
      Player.Y:=Player.Y-1;
  end;
end;


Aber noch einen Tip:

Organisiere deinen Code besser! Sonst stirbt dein Projekt an Unübersichtlichkeit!

Noch 'ne Frage: Was um alles in der Welt willst du mit dem wegfindhg-Array? Da steht doch nur der Index drin, oder soll der noch ausgebaut erden?


mimi - Di 24.06.03 20:02
@Simon Joker
kann ich den code für ein packman clone auch verwenden ?


Pyr0cracker - Di 24.06.03 21:04
Hallo Simon
das mit deinem Code ist mir nicht so klar, aber ich habs shcon hinbekommen *puh*

Danke trotzdem!

Zitat:
Organisiere deinen Code besser! Sonst stirbt dein Projekt an Unübersichtlichkeit!

Hmm ich dachte das wär schon ganz gut :cry:
Kannst mir einen Tip geben wie ich das noch besser machen kann?
Zitat:
Noch 'ne Frage: Was um alles in der Welt willst du mit dem wegfindhg-Array? Da steht doch nur der Index drin, oder soll der noch ausgebaut erden?

Genau, da kommen noch einige andere Abfragen rein, z.B. ob die Fläche frei oder blockiert ist.


Simon Joker - Mi 25.06.03 10:27
Hi Leute

@mimi

sicher kannst du ihn verwenden, aber ob er dir was nützt ist eher fraglich. Es wird ja noch nicht abgefragt, ob irgentwo Hindernisse im weg sind.

@Pyr0cracker

Vorschlag für die Organisation:

Da du nicht Objektorientiert programmierst, sondern nur die Standardevents füllst, solltest du dir für jeden Aufgabe wenigstens eine eigene Unit erstellen. In den UnitMain (Formularunit) würde ich nur die elemtare Verwaltung implementieren.
Also einige Beispiele:
UnitMain
-Eventverwaltung/Weiterleitung an die entsprechenden Units
-Objektverwaltung
-Hauptzeichenverwaltung
im Timerevent sollten nur Zeichenroutinen der einzelnen Units aufgerufen werden. Ich habe bei meinem Projekt einige Zeichenproceduren mit 3000 Zeilen, wenn die alle in einer Procedure sind hast du verloren!

Unit Player
Alle Einstellungen, Variablen, Berechnungen uns so weiter hierrein.

Unit DrawTools
Bei jedem Spiel werden einige Elemente immer wieder benötigt. Wie zum Beispiel Infoboxen, Abfragen, Warnungen, Buttons, Designelemente. Da du die nich jedesmal neu programmieren willst, die Zeichenfunktion hier hin.

Unit KI
Einige Berechnungen werden wohl für den Player sowie die NPC's benötigt. Hier erstellen.

Diese List lässt sich beliebig erweitern. Mein Projekt ist ein Strategiespiel ala MoO und hat mittlerweile ca. 35000 Zeilen primären Code in 3 Dutzend Units. Der Überblick bleibt nur erhalten, weil ich mich streng an einen einheitlichen Aufbau debn Units gehalten habe.

Noch was. Ordne deine Proceduren nach dem logischen Ablauf und der Zusammengehörigkeit. Für die Unit Main:
//Alle Initialisierungen&Deinitialisirungen des Formulars
FormCreate;
FormShow;
FormHide;
FormDestroy;
usw;
//Alle Events
OnClick
OnDoubleClick
OnMouseDown
OnMousMove
OnMouseUp
OnKeyDown
OnKeyPress
OnKeyUp
//USW

Noch ein Tip:
Für den MuasClick auf des TDXDraw würde ich das Event OnMouseUp verwenden und nicht OnClick. Vorteil: ClickKoordinaten werden übergeben, Maustasten und Shiftstatus sind bekannte und ud kannst eine Ereignissvorschau mit OnMausDown machen Zum beispiel den voraussichtlichen PFad visualisieren, den die Spielerfigur nehmen wird.

Zur Wegfindungs-KI

Das was ich geschrieben habe macht findet ja nur den kürzesten Weg zum Ziel. Es werden keine Hindernisse abgefragt oder die Bekanntheit der Karte überprüft. Um sowas zumachen würde ich Zwischenziele errechnen lassen, die dann nacheinander abgearbeitet werden.


Pyr0cracker - Mi 25.06.03 12:40
ups, ich dachte mit verschiedenen prozeduren und funktionen wäre das schon oop :lol:
aber mit den untis das hört sich gut an. nur verstehe ich das noch nicht so ganz(eine unit is doch sowas wie ein fenster oder nicht?)
kannst du mir ein kleines beispiel geben?

Danke und Gruß,


Simon Joker - Mi 25.06.03 13:35
Naja soganz falsch liegst du mit deiner Meinung zu OOP nicht, ABER du verwendest nur die Objekte die bereitgestellt werden und ie haben ja nicht die Eigenschaften und MEthoden, die du für dein Spiel benötigst. Zum Beispiel ist dein Player ein Sprite. Eigentlich sollte das doch eine Klasse TPlayer oder ähnlich sein, die alle Eigenschaften eines Spielers kapselt. So auch eine Eigenschaft PlayerPic hat, die dann das Sprite zur Darstellung referenziert.

Zur Unit. Du musst die Unit und das Formular schon auseinanderhalten. Eine Unit ist eine Sammlung von Funktionen, Proceduren und Variablen. Eine FormularUnit enthält allen Code für das Formular einschliesslich der Typdefinition für das Formular. Uver NEU->NEU->Unit kannst du eine Unit ohne Inhalt in dein Projekt einfügen.
Die reine Definition für die Unit sieht so aus:

Quelltext 
1:
2:
3:
4:
5:
6:
7:
 
unit Unit1;

interface

implementation

end.


Als Beispiel:

Ich habe Gnadenlos tausende Zeilen gelöscht, meist stehen nur noch die Procedurköpfe. Du kannst soundso nicht viel damit anfangen ohne alle Unit zu haben. Aber das Prinzip ist klar.

Erstmal die UnitMain

Delphi-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
 
unit UnitMain;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ComCtrls, StdCtrls, Grids, ExtCtrls, DXDraws, UniversTypeDef,
  Buttons, Math, DXSprite, EzRgnBtn, DXClass, GenerateUnivers,
  AddTools, DIB, StringVar, MMSystem, PlayMessage, Wave, DXSounds, Menus, Jpeg,
  Goverment, Research, Diplomatie, Fleets, Leader, PlanetTable, KITools;

type
  TFormMain = class(TDXForm)
    
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    
  end;


var
  FormMain: TFormMain;


implementation

uses UnitStarMap, Geometrie, UnitGlobalVar, UnitSplash, UnitSystemMap,
  MainMenu, LoadGame, SaveGame, NewGame, Options,
  LoadSaveSettings, PlaySound, PlanetView;

{$R *.DFM}


//********************** Initialize Game ********************

function NewRes(XRes, YRes, Depth: DWORD): Integer;

procedure TFormMain.RestoreFSurface;

procedure TFormMain.ResetResolution;

procedure TFormMain.SetResolution(XRes, YRes, Depth: DWORD);

procedure TFormMain.RestoreResolution;

procedure TFormMain.HideSplash;

procedure TFormMain.MinimizeByDeaktivate(Sender: TObject);
begin
  if not Cheat and (WindowState=wsMaximized) then begin
    RestoreResolution;
    WindowState:=wsMinimized;
  end;
end;

procedure TFormMain.InitializeByAktivate(Sender: TObject);

procedure TFormMain.SetzeCursor(Cursor:integer);

procedure TFormMain.FormCreate(Sender: TObject);

procedure TFormMain.FormClose(Sender: TObject; var Action: TCloseAction);

procedure TFormMain.FormShow(Sender: TObject);

procedure TFormMain.InitializeGraphikDisplay;

procedure TFormMain.DXDrawInitializeSurface(Sender: TObject);

procedure TFormMain.DXDrawFinalizeSurface(Sender: TObject);

procedure TFormMain.TimerStartTimer(Sender: TObject; LagCount: Integer);

procedure TFormMain.TimerSetResTimer(Sender: TObject);

//Anordnung der Buttons

procedure TFormMain.ArrangeButtons;

procedure TFormMain.FormResize(Sender: TObject);

// ******************* Finalize Game ***************

procedure TFormMain.FormDestroy(Sender: TObject);
begin
  TextCon.Free;
  //FinalizeBuildFrame;
  FinalizeLoadGame;
  FinalizeSaveGame;
  FinalizeNewGame;
end;

// ******************* Finalize Intro ***************

procedure TFormMain.MMNotify(var Message: TMessage);
begin
  mciSendString('close film', nil, 0, 0);
  Show;
end;

// ********* EVENT BEHANDLUNG *********

procedure TFormMain.DXDrawMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  if IsMessageFrame then begin
    case MessageFrame of
      0: HLPMessageMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
    end;
    Exit;
  end;
  case VisibleFrame of
    1: StarMapMouseDown(DXDraw,ILSuns,ILNebel,ILStuff,Button,Shift,X,Y);
    //3: BuildMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
    4: LoadGameMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
    5: SaveGameMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
    6: NewGameMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
    7: OptionMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
    8: PlanetViewMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
    14: PlanetTableMouseDown(DXDraw,ILBuildStuff,Shift,X,Y);
  end;
end;

procedure TFormMain.DXDrawMouseMove(Sender: TObject; Shift: TShiftState;
  X, Y: Integer);

procedure TFormMain.DXDrawMouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);

procedure TFormMain.DXDrawDblClick(Sender: TObject);

procedure TFormMain.FormMouseWheel(Sender: TObject; Shift: TShiftState;
                                   WheelDelta: Integer; MousePos: TPoint; var Handled: Boolean);

procedure TFormMain.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);

procedure TFormMain.FormKeyPress(Sender: TObject; var Key: Char);

procedure TFormMain.FormKeyUp(Sender: TObject; var Key: Word;
                              Shift: TShiftState);


// ********* EVENT BEHANDLUNG ENDE *********

// *************** ShowFrames *******************

procedure TFormMain.LoadButtonImg(Frame: integer);

procedure TFormMain.SetVisibleFrame(Frame: integer);

procedure TFormMain.TimerAnimationTimer(Sender: TObject; LagCount: Integer);
begin
  case VisibleFrame of
    0: DrawMainMenu(DXDraw,ILMenuStuff);
    1: DrawStarMap(DXDraw,ILSuns,ILNebel,ILStuff);   //change
    2: DrawSystemMap(DXDraw,ILSuns,ILPlanets,ILStations,ILStuff);
    //3: DrawBuild(DXDraw,ILBuildStuff);
    4: DrawLoadGame(DXDraw,ILMenuStuff);
    5: DrawSaveGame(DXDraw,ILMenuStuff);
    6: DrawNewGame(DXDraw,ILMenuStuff);
    7: DrawOption(DXDraw,ILMenuStuff);
    8: DrawPlanetView(DXDraw,ILMenuStuff);
    9: DrawGoverment(DXDraw,ILMenuStuff);
    10: DrawResearch(DXDraw,ILMenuStuff);
    11: DrawDiplomatie(DXDraw,ILMenuStuff);
    12: DrawLeader(DXDraw,ILMenuStuff);
    13: DrawFleets(DXDraw,ILMenuStuff);
    14: DrawPlanetTable(DXDraw,ILMenuStuff);
  end;
end;

// *************** ShowFrames ENDE *******************

// *************** VCL-Button-Events *****************
// SysMenü
procedure TFormMain.BuMenuRegClick(Sender: TObject);

procedure TFormMain.TiAnimateMenuTimer(Sender: TObject; LagCount: Integer);

procedure TFormMain.ImgBorderClick(Sender: TObject);

//SysMenüButton

procedure TFormMain.BuMainMenuClick(Sender: TObject);
begin
  SetVisibleFrame(0);
end;

procedure TFormMain.BuNewGameClick(Sender: TObject);
begin
  SetVisibleFrame(6);
end;

procedure TFormMain.BuSaveGameClick(Sender: TObject);
begin
  SetVisibleFrame(5);
end;

procedure TFormMain.BuLoadGameClick(Sender: TObject);
begin
  SetVisibleFrame(4);
end;

procedure TFormMain.BuOptionClick(Sender: TObject);
begin
  SetVisibleFrame(7);
end;

procedure TFormMain.BuExitClick(Sender: TObject);
begin
  Close;
end;

procedure TFormMain.BuFullClick(Sender: TObject);
begin
  ResDefault:=false;
  SetResolution(ResWidth,ResHeight,ResDepth);
end;

//MainFrameButtons

procedure TFormMain.BuStarMapClick(Sender: TObject);

procedure TFormMain.BuSystemClick(Sender: TObject);
begin
  if not (VisibleFrame=2) then
    begin
      PlayEffect(1);
      SetVisibleFrame(2);
    end;
end;

procedure TFormMain.ImgBorderMouseMove(Sender: TObject;
  Shift: TShiftState; X, Y: Integer);
begin
  SetDefaultMouseOrderState;
end;

procedure TFormMain.BuRgnEnter(Msg: TWMMouse);
begin
  SetDefaultMouseOrderState;
end;

//*************Cheatbehandlung**********

procedure TFormMain.AlleSystemebekannt1Click(Sender: TObject);

procedure TFormMain.DiesesSytembekannt1Click(Sender: TObject);

procedure TFormMain.CoBoDiplayModiChange(Sender: TObject);

procedure TFormMain.Gebudefertig1Click(Sender: TObject);

procedure TFormMain.LaCheatClick(Sender: TObject);

end.


Als Representant für die Units: Die SaveGameUnit im Grunde sind für alle verschiedenen Seiten des Spiels die Unit gleich aufgebaut. Die einzelnen Routinen werden von der UnitMain aus aufgerufen.

Delphi-Quelltext 
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
 
unit SaveGame;

interface
  uses comctrls, Sysutils, Math, Geometrie, UniversTypeDef, Windows, Graphics, DXDraws,
       UnitGlobalVar, Controls, Classes, AddTools, StringVar, LoadSaveGame;

  procedure InitializeSaveGame;
  procedure FinalizeSaveGame;
  procedure DrawSaveGame(DrawArea:TDXDraw;ILMenuStuff:TDXImageList);
  procedure SaveGameClick(DrawArea:TDXDraw;ILMenuStuff:TDXImageList;
                          Button: TMouseButton;Shift: TShiftState;X, Y: Integer);
  procedure SaveGameScroll(DrawArea:TDXDraw;ILBuildStuff:TDXImageList;
                           WheelDelta:integer;Shift:TShiftState;MousePos: TPoint);
  procedure SaveGameMouseDown(DrawArea:TDXDraw;ILBuildStuff:TDXImageList;
                              Shift: TShiftState;X, Y: Integer);
  procedure SaveGameMouseMove(DrawArea:TDXDraw;ILBuildStuff:TDXImageList;
                              Shift: TShiftState;X, Y: Integer);
  procedure SaveGameKeyUp(var Key: Word;Shift: TShiftState);
  procedure SaveGameKeyPress(var Key: Char);

implementation

uses UnitMain;

procedure InitializeSaveGame;

procedure FinalizeSaveGame;

procedure DrawSaveGame(DrawArea:TDXDraw;ILMenuStuff:TDXImageList);

procedure SaveGameClick(DrawArea:TDXDraw;ILMenuStuff:TDXImageList;
                         Button: TMouseButton;Shift: TShiftState;X, Y: Integer);
begin
  if StartButton<>MouseOverButton then exit;
  case MouseOverButton of
    0:if ButtonEnabled[0] then begin
        FormMain.SetVisibleFrame(LastVisibleFrame);
      end;
    1:if ButtonEnabled[1] then begin
        //SaveGame
        if not SaveGameToFile(SelGameStr) then ;//ShowMessage('sche****');
        FormMain.SetVisibleFrame(LastVisibleFrame);  //Change 1
      end;
    //2:; LoadGameName
    3: dec(SaveGameListPos); //up
    4: inc(SaveGameListPos); //down
    5: dec(SaveGameListPos,((DrawArea.Height-50-3)-(80+3)) div 16); //page up
    6: inc(SaveGameListPos,((DrawArea.Height-50-3)-(80+3)) div 16); //page down
    //7:; Track
    8: if SaveGameListHL>=0 then begin  //Item select
         SaveGameListSel:=SaveGameListHL;
         SelGameStr:=SaveGameList.Names[SaveGameListSel];
         SelGameStrSelStart:=0;
         SelGameStrSelLength:=Length(SelGameStr);
         SelGameStrPos:=Length(SelGameStr);
       end;
    9: ;//DeleteFile
    10: dec(AddInfoListPos); //up
    11: inc(AddInfoListPos); //down
    12: dec(AddInfoListPos,((DrawArea.Height-50-3)-(258)) div 16); //page up
    13: inc(AddInfoListPos,((DrawArea.Height-50-3)-(258)) div 16); //page down
    //14:; Track
    15: if AddInfoListHL>=0 then AddInfoListSel:=AddInfoListHL;  //Item select
  end;
end;

procedure SaveGameScroll(DrawArea:TDXDraw;ILBuildStuff:TDXImageList;WheelDelta:integer;Shift:TShiftState;MousePos: TPoint);

procedure SaveGameMouseDown(DrawArea:TDXDraw;ILBuildStuff:TDXImageList;
                       Shift: TShiftState;X, Y: Integer);

procedure SaveGameMouseMove(DrawArea:TDXDraw;ILBuildStuff:TDXImageList;
                          Shift: TShiftState;X, Y: Integer);

procedure SaveGameKeyPress(var Key: char);

procedure SaveGameKeyUp(var Key: Word;Shift: TShiftState);

end.



Die ganze Sache wird dir etwas verwirrend erscheinen, aber es ist immer noch übersichtlichen als wenn der ganze Code in der Formular unit steht.

Wenn du mehr brauchst dann melde dich noch mal.


Mr_T - Mi 25.06.03 22:10
Also ich habe vor einer halben Ewigkeit (muss etwa 1,5 Jahre her sein) mal etwas mit pathfinding rumexperimentiert...
ich weiß nicht, inwiefern es für dich brauchbar ist, aber ich habe das Programm hier einfach mal hochgeladen:
http://mitglied.lycos.de/dcwmrt/delphi/path.zip
Der Code mag zwar chaotisch aussehen und kaum optimiert sein 8war ja nur ne spielerei von mir), aber es funtz... evtl. gibtes dir ja ein Paar Denkanstöße...
Die bedienung ist recht easy:
Der blaue Punkt ist der Start, der Rote das Ende. Nun kann man mit der Maus auf die Fläche dazwischen klicken und damit die "Festen" Punkte (schwarz) setzen... wenn man fertig ist, muss man nur auf "Calc" klicken, und der kürzeste weg wird berechnet und in Form einer grünen "Schlange" angezeigt... naja: sieh es dir an und gucke, ob du damit evtl. was nafangen kannst.....


Pyr0cracker - Do 26.06.03 13:32
Hi,
ich werde mal versuchen das mit oop umzusetzen.
danke für das beispiel!

noch mal zum pathfinding:
hab jetzt ein massives objekt eingebaut und was ist das ergebniss? BUG BUG BUG :x
(hier [http://www.lesta.de/dorian/Htmlseiten/meinesachen/arraybug.zip] gibts noch mal das neue beispiel. bitte schaut doch mal ob ihr den fehler findet (ich bin schon seit einigen stunden am suchen... :shock: )

@Mr_T: dein link geht nicht. tripod macht da stress wenn du nicht von deiner hp auf die datei linkst.

DANKE und GRUß,


Mr_T - Do 26.06.03 16:30
Nagut, wenn nicht so, dann so:
http://mitglied.lycos.de/dcwmrt/index.html
(Auf der Html-Site befindet sich ein Link zur File.....)


M4EiB - Do 26.06.03 20:58
dann will ich meinen a*-algo auch mal präsentieren:
mir gings auch nur um eine erfolgreich umsetzung, ist also keinesfalls optimiert (ein array anstatt der tlist würde die sache wohl schneller machen, vll teste ich das mal)
außerdem rechnet die implementierung mit kosten pro schritt (was die sache auch langsamer macht, binäre suche beim einfügen eines neuen schritts würde die sache wohl auch sehr beschleunigen). das heißt, man kann ein feld bewerten. so ist es ein unterscheid, ob man nun durch z.b. sumpf läuft oder auf der straße :lol: .wenn man das costs-array 2 dimensonal macht, könnte man auch noch unterscheiden, in welche richtung das feld überquert wurde, und so berge und täler simulieren.


aber testet selbst:http://xmhondura.batcave.net/pathfinder.zip (in neues fenster kopieren, damit referer aus ist (freewebspace pur))


UGrohne - Do 26.06.03 21:09
Kann man leider net runterladen.... :(


Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2026 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!