# Prolog Problem



## Razorhawk (12. Juni 2005)

Ich weiß nicht ob mir hier jemand helfen kann, aber ich versuchs.
Es geht um die logische Programmiersprache Prolog.

Hier erstmal der Quelltext


```
% Ein Labyrinth besteht aus Zeilen von Feldern.
% Nachbarfelder sind durch eine Wand getrennt oder
% der Durchgang zum Nachbarfeld ist offen.
%
% Das hier betrachtete Labyrinth hat die folgende Form:
%
%   --------------
%  |             |      |
%  |  a1     a2  |  a3  |
%  |             |      |
%          ------       |
%                       |
% --> b1     b2     b3  |
%                       |
%  |       ------       |
%  |                    |
%  |  c1     c2     c3  |
%  |                    |
%   --------------------
%
% Die Felder werden mit a1, a2, usw. bezeichnet.
% Der Pfeil --> zeigt das Startfeld und die Anfangsrichtung, in der das
% Labyrinth betreten werden kann. Am Zielfeld ist ein Ausgang gezeichnet.



% Definition des Labyrinths durch Relationen offen/3 und wand/3
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Bezeichnung der Himmelsrichtungen: osten, sueden, westen, norden
% Das Praedikat offen(Von, Nach, Richtung) beschreibt,
% in welcher Richtung die Maus vom Feld Von zum Feld Nach gelangen kann.
% Es ist nur notwendig, die Fakten fuer osten und sueden anzugeben,
% da offen(Von, Nach, westen) durch offen(Nach, Von, osten) gegeben ist
% und offen(Von, Nach, norden) durch offen(Nach, Von, sueden).


offen(b1,b2, osten).
offen(c1,c2, osten).

offen(c2,c3, osten).
offen(a1, a2, osten).
offen(b2, b3, osten).

offen(a1, b1, sueden).
offen(b1, c1, sueden).
offen(a3, b3, sueden).
offen(b3, c3, sueden).

offen(F1, F2, westen):- offen(F2, F1, osten).
offen(F1, F2, norden):- offen(F2, F1, sueden).

% Im Labyrinth gibt es drei Waende, eine nach Osten und zwei Waende nach
% Sueden.
% Die Waende fuer Westen und Norden lassen sich aehnlich wie bei offen/3
% definieren.
wand(a2, a3, osten).
wand(a2, b2, sueden).
wand(b2, c2, sueden).

% wand(b1, b2, osten). % Diese beiden Waende versperren
% wand(c1, c2, osten). % den Weg zum Ausgang

wand(F1, F2, westen):- wand(F2, F1, osten).
wand(F1, F2, norden):- wand(F2, F1, sueden).

% Es gilt nachbar(Feld1,Feld2,Richtung), wenn fuer Feld1, Feld2 und
% Richtung die Relation offen/3 oder  wand/3 gilt.
% (Im Labyrinth gibt es in eine Richtung hoechstens einen Nachbarn.)
nachbar(X,Y,Ri):-offen(X,Y,Ri); wand(X,Y,Ri).

% Definition der Maus
%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Die Maus ist durch ihre Stellung und ihre Richtung beschrieben.

% Die Maus befindet sich am Anfang auf dem Startfeld
startFeld(b1).

% Sie hat die Anfangsrichtung Osten, weil sie von Westen in das Labyrinth kommt:
startRichtung(osten).

% Sie soll das Zielfeld a3 erreichen:
zielFeld(a3).


% Die Maus kann sich nach links oder rechts drehen

% Beim Drehen nach rechts aendert man die Richtung1 in die Richtung2 z.B.
% von norden nach osten, von osten nach sueden usw.:
rechtsDrehen(norden,osten).
rechtsDrehen(osten,sueden).
rechtsDrehen(sueden,westen).
rechtsDrehen(westen, norden).

% linksDrehen kann mit Hilfe von rechtsDrehen implementiert werden.
linksDrehen(X,Y):-rechtsDrehen(Y,X).

% Wegsuche der Maus:
% Die Wegsuche zum Ziel beginnt auf dem Startfeld in der vorgegebenen Startrichtung.
% Der Weg wird durch die angenommenen Stellungen der Maus (Feld, Richtung) dokumentiert.
% Beim Start hat die Maus die Stellung (Startfeld, Startrichtung).
% Der Weg zum Ziel wird mit Hilfe von sucheZiel/4 bestimmt.
wegsuche:-
        startFeld(X), write('Start wegsuche/0: '), nl, startRichtung(R),
        ausgabeMaus(X, R), sucheZiel(X, R, [(X, R)], Weg), ausgabeLabyrinth(Weg).


% Die Maus hat die Stellung (Feld, Richtung) und
% hat von dem Startfeld aus bereits die in der Liste WegGelaufen
% enthaltenen Stellungen angenommen.
% Nach der folgenden Strategie bestimmt sie weitere Aktionen, die sie zum
% Ziel fuehren:
% Ein Mal nach links drehen und dann zum Nachbarfeld, falls moeglich,
% sonst geradeaus, falls moeglich,
% sonst ein Mal nach rechts drehen und dann zum Nachbarfeld, falls moeglich,
% sonst zwei Mal nach rechts drehen und zurueckgehen,
% ausser auf dem Startfeld (kein Weg zum Ziel!)
%
% Als Ergebnis enthaelt WegZumZiel alle Stellungen der Maus vom Startfeld
% zum Zielfeld.

sucheZiel(Feld,Richtung,WegGelaufen,[(Feld,Richtung)|WegGelaufen]):- zielFeld(Feld).


linksdrehe(Feld,Richtung,WegGelaufen,[(Feld,Richtung)|WegGelaufen]):- zielFeld(Feld).
linksdrehe(Feld,Richtung,WegGelaufen,WegZumZiel):- not((startFeld(Feld), startRichtung(Richtung))), linksDrehen(Richtung,RLinks), offen(Feld,FLinks,RLinks), linksdrehe(FLinks,RLinks,[(Feld,Richtung)|WegGelaufen],fastWegZiel), WegZumZiel = fastWegZiel.
```

Nun mein Problem:

an sich habe ich theoretisch alles durch wie das geht... jetzt bin ich am schreiben und wollte erstmal ein Testprädikat implementieren und zu checken ob meine Strategie richtig ist.

also ich habe nur den Teil dass er sich nach links dreht und meine anfrage sieht so aus ums zu testen:

linksdrehen(b3,osten,[(a2,osten)],X).

also ich geh mal davon aus, dass ich vorher auf a2 war und nun auf b3 bin und dann nurnoch nach links drehe, sehe dass da offen ist und auf a3 gehe und der Rekursionsanfang erkennt, dass er aufm Zielfeld steht und die rekursion wieder zurück geht.
So nun meine 2 prädikate dazu, aber irgendwie scheint er den Rekusionsanfang nicht zu beachten und ich weiß nicht warum.
Nur am Anfang testet er es und es scheitert, klar, aber bei späteren Rekursionsstufen checkt er das nicht mehr und so bekomme ich dann immer ein "No" wenn er nach (a3,norden) versucht ein offenes feld (a3,westen) zu finden, was es ja nicht gibt, da dort eine Wand ist!

Also wo ist mein Fehler verdammt nochmal Very Happy

Mein Testprädikat:


linksdrehen(Feld,Richtung,WegGelaufen,[(Feld,Richtung)|WegGelaufen]):- zielFeld(Feld).

linksdrehen(Feld,Richtung,WegGelaufen,WegZumZiel):- not((startFeld(Feld), startRichtung(Richtung))), linksDrehen(Richtung,RLinks), offen(Feld,FLinks,RLinks), linksdrehen(FLinks,RLinks,[(Feld,Richtung)|WegGelaufen],fastWegZiel), WegZumZiel = [(Feld,Richtung)|fastWegZiel].


----------

