Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

maty

Frischling

  • »maty« ist der Autor dieses Themas
  • Private Nachricht senden

1

16.09.2006, 11:13

kürzeste strecke zwischen 2 punkten mit zwischenpunkten

hi,

allso ich entwickle ein 2D Spiel und wollte mal schauen ob da jemand bei meinem problem vileicht was weiss.

Allso auf meiner Landkarte sind ca. 120 Städte, nun würde ich gern die kürzeste Strecke zwischen 2. Sädten ermitteln.

zb.:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
//start: stadt[1]  CPoint{10,20}

//ziel: stadt[110] CPoint{560,200}


//als ergebnis hätte ich da gern dann zb:

stadt[1]  CPoint{10,20}  //Startstadt

1. knoten:stadt[6]  CPoint{30,60}
2. knoten:stadt[29]  CPoint{130,90}
3. knoten:stadt[42]  CPoint{240,120}
.
.
.
stadt[110] CPoint{560,200}  //Zielstadt


er müste dann also alle dazwischen liegende städte ermitteln um so eine route zu zeichnen.

gibt es da schon code dazu oder weiss wer wo da was steht, hab bis jetzt nur so 3D Sachen gefunden, aber ich brauch ja 2D

werde falls es da nix zu gibt wohl von beiden städten aus die entfernungen zu nachbarstädten messen müssen, und von denen wieder zur allen nächsten, bis von beiden seiten eine gleiche getroffen wird - oder so in der art ;)

Grüsse, Maty :)

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

16.09.2006, 11:19

A-Star (A*) ist ein sehr beliebter Wegfindealgorithmus, und der sollte sich hier auch anwenden lassen.

maty

Frischling

  • »maty« ist der Autor dieses Themas
  • Private Nachricht senden

3

16.09.2006, 11:27

danke David,
werd mal grade danach suchen im web oder haste zufällige nen link zum code zur hand, hoffe der muss nich per dll eingebunden werden das mag ich ja nich so sehr ;)

Grüsse, Maty :)

maty

Frischling

  • »maty« ist der Autor dieses Themas
  • Private Nachricht senden

4

16.09.2006, 11:43

hab das hier gefunden, aber der code ist wohl sehr seltsam und kein c++ - sieht wie pascal aus oder so, weiss gar nicht wo ich da mit meinen CPoint -Arrays hinsoll ...


C-/C++-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
/*
 * Algorithmus zur Rekonstruktion des kürzesten Pfades
 * ---------------------------------------------------
 * P: berechneter kürzester Pfad
 * start: Startknoten
 * node: Zielknoten
 */
reconstruct_shortest_path (start, node, graph)
{
   if (node != start)
   {
      push(node, P);

      // Lese den Vorgänger des aktuellen Knoten aus

      predecessor := getPredecessor(node, graph);

      reconstruct_shortest_path (start, predecessor, graph)
   }
   else
      return P;
}

/*
 * Der eigentliche A*-Algorithmus
 * ------------------------------
 * graph: Zu untersuchender Graph
 * start: Startknoten
 * goal: Der Zielknoten
 * h: Heuristikfunktion zum Schätzen des Abstandes eines Knotens bis zum Ziel
 * S: Prioritätswarteschlange der Knoten, deren f-Wert bereits bekannt ist
 * N: Liste aller bereits besuchten Knoten
 */
A-Star (graph, start, goal, h, S, N)
{
   insert (start,S);
   while not isEmpty(S)
   {
      current_node := pop(S);
      if current_node in N then
         // Es existiert kein Pfad vom Start zum Ziel

         return fail;
      insert (current_node, N);
      if (current_node == goal) then
         return reconstruct_shortest_path(start,goal, graph);
      else
      {
         // Finde alle vom aktuellen Knoten aus erreichbaren Knoten

         successors := expand(current_node, graph);

         // Speichere Vorgänger des expandierten Knotens im Graph

         save_predecessor_in_graph(current_node, graph)

         forall s in sucessors do
         {
            // Speichere Knoten von dem aus s erkundet wurde

            predecessor(s) := current_node;

            // Berechne und speichere die f-Kosten

            f(s) := g(s) + h(s);

            insert(s,S);
         }
      }
   }
   // Es konnte kein Pfad gefunden werden

   return fail;
}

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

5

16.09.2006, 11:48

Du sollst dir ja auch keinen Code suchen, sondern dich über den Algorithmus informieren und den dann selber implementieren. Nur so kannst du selbst was lernen.

maty

Frischling

  • »maty« ist der Autor dieses Themas
  • Private Nachricht senden

6

16.09.2006, 12:15

oh ja da geb ich dir recht,
mag eh keinen code den ich nicht nachvollziehen kann, hab da eben noch so ca 1 meter code zu A-Star gesehen :roll: da schreib ich mir lieber selber was und weiss was mein code so anstellt :)

hier schon mal ne beschreibung:

Zitat

Wendet man den A*-Algorithmus auf einem Knoten u an, so werden zuerst alle von diesem Knoten aus erreichbaren Nachbarn berechnet. Danach wird durch die Heuristik für jeden dieser Nachbarn eine Schätzung abgegeben, wie teuer es ist, von ihm aus zum Ziel zu kommen. Für jeden dieser Nachbarknoten v addiert der A*-Algorithmus nun die von der Heuristik geschätzten Kosten bis zum Ziel zu den Kosten, um vom Knoten u zu eben jenem Knoten v zu kommen. Die Vorgehensweise des Algorithmus lässt sich dabei durch folgende Gleichung beschreiben:

f(v) = g(v) + h(v)

Hierbei steht h(v) für die von der Heuristik für Knoten v geschätzten Kosten bis zum Ziel, g(v) für die bisherigen gesamten Wegkosten um vom Knoten bei dem man den A*-Algorithmus gestartet hat zum Knoten v zu kommen, und f(v) steht für die wahrscheinlich zu erwartenden Kosten, wenn man vom Startknoten aus über seine aktuelle Position (u) zu dem entsprechenden Nachbarn (v) weitergeht, um von dort aus irgendwie weiter zum Ziel zu gelangen. Im nächsten Schritt wird nun der Knoten weiter untersucht, welcher den geringsten f-Wert besitzt.


werde zu spielbeginn mir da ne tabelle(arraymap) ertsellen, so braucht er nur einmal alle möglichen wege zu suchen, geht dann schneller hoff ich ...

PS: hab grad gesehen das in Spielegems1 ja auch was zu A* steht, gleichmal durcharbeiten.

Grüsse, Maty :)

Werbeanzeige