Eingereicht von Extinction:
Um es etwas zu vereinheitlichen:
das Programm muss ein Spielbrett einlesen können:
####
####
####
Dieses hat ein Format "n * m". Also n Zeilen zu m Spalten. Ihr könnt davon ausgehen, dass alle Bretter rechteckig sind.
Dabei gibt ein '#' ein freies Feld an, ein Großbuchstabe (außer Z) den Spieler (und damit seine Koordinaten) und das Z steht für Ziel. Alle anderen Zeichen sind als Hindernisse zu betrachten.
Das Programm soll den Weg von dem aktuellen Punkt mit dem Spieler zum Zielpunkt berechnen und ausgeben. Die Ausgabe kann grafisch sein (wer mag) oder simpel mit (x,y) Koordinaten erfolgen (nur eben einheitlich):
(3, 4) -> (3, 3) -> (2, 3) -> Ziel
Einfache Version: der Spieler kann sich nicht diagonal bewegen, nur links/rechts/oben/unten. Der Algorithmus muss nicht "Realapplication" tauglich sein
Schwere Version: der Spieler kann sich auch diagonal bewegen.
Also oben/unten/links/rechts/oben-rechts, oben-links usw.
Der Algorithmus/Ansatz muss halbwegs "Realapplication" tauglich sein - z.B für 30 Spielfiguren auf einem 100x100 Spielfeld [0].
Dabei muss der Weg nicht nachweisbar der "kürzeste" sein - sollte aber nicht zu sehr davon abweichen.
Bsp Karte mit Figuren A, B und Zielpunkt Z, dazu mit "Hindernissen":
[0] das ist jetzt Pi mal Daumen geschätzt und kommt auch auf die benutzte Sprache und andere Faktoren an
- ihr solltet einfach (in etwa )einschätzen können, ob eure Umsetzung mehrere Routen pro Sekunde für ein halbwegs realistisch gerastertes Spielfeld schafft 
Ausgangssituation ist ein in gleich große Quadrate unterteiltes Spielfeld, wie ein Schachbrett. Wir haben eine Figur A, welche zum Punkt B gelangen soll. Hierfür ist der/die Kürzeste/n Weg/e zu berechnen.
Zunächst auf freiem feld, was recht einfach währe.
Dann, um ein Hinderniss herum.
Und zuletzt auch durch ein Labyrinth.
Um es etwas zu vereinheitlichen:
das Programm muss ein Spielbrett einlesen können:
####
####
####
Dieses hat ein Format "n * m". Also n Zeilen zu m Spalten. Ihr könnt davon ausgehen, dass alle Bretter rechteckig sind.
Code:
###=#Z#
~######
##...+#
#######
#A#####
Dabei gibt ein '#' ein freies Feld an, ein Großbuchstabe (außer Z) den Spieler (und damit seine Koordinaten) und das Z steht für Ziel. Alle anderen Zeichen sind als Hindernisse zu betrachten.
Das Programm soll den Weg von dem aktuellen Punkt mit dem Spieler zum Zielpunkt berechnen und ausgeben. Die Ausgabe kann grafisch sein (wer mag) oder simpel mit (x,y) Koordinaten erfolgen (nur eben einheitlich):
(3, 4) -> (3, 3) -> (2, 3) -> Ziel
Einfache Version: der Spieler kann sich nicht diagonal bewegen, nur links/rechts/oben/unten. Der Algorithmus muss nicht "Realapplication" tauglich sein

Schwere Version: der Spieler kann sich auch diagonal bewegen.
Also oben/unten/links/rechts/oben-rechts, oben-links usw.
Der Algorithmus/Ansatz muss halbwegs "Realapplication" tauglich sein - z.B für 30 Spielfiguren auf einem 100x100 Spielfeld [0].
Dabei muss der Weg nicht nachweisbar der "kürzeste" sein - sollte aber nicht zu sehr davon abweichen.
Bsp Karte mit Figuren A, B und Zielpunkt Z, dazu mit "Hindernissen":
Code:
#====================================+
|#########//\\#################Z#####|
|########//##\\######################|
|#############\\######\----------/\/\|
|##############\\####################|
|####//\\############################|
|#######\\###()()()()()##############|
|########\\#####\\\\\\\##############|
|#########\\\########################|
|####################################|
|####################################|
|####################################|
|#A##############################B###|
|####################################|
+====================================+
[0] das ist jetzt Pi mal Daumen geschätzt und kommt auch auf die benutzte Sprache und andere Faktoren an


Zuletzt bearbeitet: