Java Hamstersimulator Komplexe Programmierung

[KarlDerGrosse]

Hallo zusammen,
ich habe mir eine kleine Aufgabe selber erstellt und komm leider nicht weiter.
Zu der Welt ist folgendes zu sagen.
Die Kammer muss ausgezählt werden (erledigt)
Die Körner müssen gezählt werden und durch die Anzahl der KammerFelder geteilt werden (erledigt)
Der Hamster soll die Gänge ablaufen und die Kammer finden, die Eingänge der einzelnen Verzweigungen sind nie
auf einer Höhe zudem soll der Code auch funktonieren wenn die Gänge verändert werden.
(Hier funktoniert bei mir nur das er die Gänge durchläuft, aber nicht die Kammer Findet (mit Glück läuft er wieder raus) und wenn ein Gang ganz unten abgeht (so wie im Beispiel) dann läuft er da nicht rein. Er läuft bei mir auch wieder nach oben raus zum Schluss aber er ist in einer Schleife gefangen und läuft die ganze Zeit hin und her)

Wenn ich meinen Quelcode Posten soll sagt bitte bescheid sind so ca 300Zeilen +

Über jede Hilfe bin ich dankbar :-)

 

[Taigabaer]

Ich muss ehrlich gestehen, ich hab keine Ahnung und das auch nicht so ganz verstanden, aber wenn der Hamster sich immer rechts (an den Wänden entlang) hält läuft er letztendlich automatisch jeden Gang/jede Kammer ab. (Zumindest in diesem Dungeon und in jedem anderen, der keine Kammer mit freistehender "Mittelsäule" enthält) Auch könnt er sich stur links halten, mit dem gleichen Ergebnis. Letztendlich landet er beim Ausgangspunkt und hat alle Gänge/Kammern abgelaufen.

Ok, das mit der "Kammerfelderauszählung" funktioniert dann wohl nicht, sorry, bin absoluter Laie.

(Vielleicht kann man, wenn er einmal links und einmal rechts alles stur durchquert hat, aus den entstandenen Daten eine potentielle Kammer "ausrechnen", wo er dann "gezielt" nochmal durchläuft.)

 

[KingLM97]

Der Quellcode wäre hilfreich. Pack ihn am besten in die [SPOILER*][/SPOILER*] Tags (ohne die Sternchen)

 

[KarlDerGrosse]

hier einmal mein Quellcode

Spoiler

void main()
{
/*
int Haufen;
int HaufenMenge;
Haufen = 0;
FindeDenHaufen();
Haufen = Haufen + HaufenMenge();
MaulLeerMachen();


EingangFinden();
GehInsLoch();
LaufeAlleGaenge();
schreib("soviele Körner habe ich im Maul: " + Haufen);
*/

InDerKammer();


}



/* ########################### Kammer auszählen ########################### */
void InDerKammer()
{

while(vornFrei())
{
vor();
}
rechtsUm();
while(vornFrei())
{
vor();
}
drehUm();
AnzahlFelder();
}

int AnzahlFelder()
{
int b;
b = 1;
int LaengeDerKammer;
while(vornFrei())
{
vor();
b = b + LaengeDerKammer();
}
b = b * b;
return b;
}

int LaengeDerKammer()
{
int a;
a = 0;
a++;
return a;
}
/* ###################################################################### */





void LaufeAlleGaenge()
{
while(linksFrei() && rechtsFrei())
{
DurchDenGangLaufen();
WiederAusDenGangFinden();
rechtsUm();
if(vornFrei())
{
vor();
}
else
{
drehUm();
}
}

}




void WiederAusDenGangFinden()
{
drehUm();
while(vornFrei())
{
vor();
}
while((linksFrei() || rechtsFrei()) && (!(linksFrei() && rechtsFrei())))
{
LaufZurueck();
}
}

void LaufZurueck()
{
if(rechtsFrei())
{
rechtsUm();
while(vornFrei())
{
vor();
}
}
else
{
linksUm();
while(vornFrei())
{
vor();
}
}
}








void DurchDenGangLaufen()
{
LaufeInsLoch();
while(linksFrei() || rechtsFrei())
{
LaufWeiter();
}
}

void LaufeInsLoch()
{
while(vornFrei())
{
vor();
}
}

void LaufWeiter()
{
if(rechtsFrei())
{
rechtsUm();
while(vornFrei())
{
vor();
}
}
else
{
linksUm();
while(vornFrei())
{
vor();
}
}
}

void GehInsLoch()
{
while(vornFrei() && !rechtsFrei())
{
vor();
}
rechtsUm();
}

void EingangFinden()
{
drehUm();
while(!rechtsFrei())
{
vor();
}
rechtsUm();
vor();
}

void MaulLeerMachen()
{
while(!maulLeer())
{
gib();
}
}

void FindeDenHaufen()
{
while(!kornDa())
{
vor();
}
}

int HaufenMenge()
{
int b;
b = 0;
int KoernerZahelen;
while(kornDa())
{
nimm();
b = b + KoernerZaehlen();
}
return b;
}

int KoernerZaehlen()
{
int a;
a = 0;
a++;
return a;
}

/* ************* Abfrage ob die Kammer gefunden wurde ************* */
/* ************* Auf funktion geprüft ************* */
boolean KammerGefunden()
{
boolean a = (KammerEingangMitte() || KammerEingangRechts() || KammerEingangLinks());
return a;
}

boolean KammerEingangMitte()
{
boolean a = (linksFrei() && rechtsFrei() && hintenFrei());
return a;
}

boolean hintenFrei()
{
drehUm();
boolean a = vornFrei();
drehUm();
return a;
}

boolean KammerEingangLinks()
{
boolean e = (HintenRechtsFrei() && rechtsFrei());
return e;
}

boolean HintenRechtsFrei()
{
drehUm();
vor();
linksUm();
boolean d = vornFrei();
linksUm();
vor();
return d;
}

boolean KammerEingangRechts()
{
boolean y = (HintenLinksFrei() && linksFrei());
return y;
}

boolean HintenLinksFrei()
{
drehUm();
vor();
rechtsUm();
boolean x = vornFrei();
rechtsUm();
vor();
return x;
}

/* ##################################################################### */

boolean linksFrei()
{
linksUm();
boolean a = vornFrei();
rechtsUm();
return a;
}

boolean rechtsFrei()
{
rechtsUm();
boolean a = vornFrei();
linksUm();
return a;
}


void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}

void drehUm()
{
linksUm();
linksUm();
}

 

[Harzerkas]

Für Code gibt es doch [code*] [/code*]

 

[Ozzy83]

Mit der Lösung oben müsste der Hamster irgendwo mal stecken bleiben und immer den gleichen, falschen Gang ablaufen und so ewig rotieren. Man muss sich schon merken wo man war und wohin man von dort gelaufen ist.

Die Masterlösung:

Du könntest dich in das "Rucksackproblem" einarbeiten. Das ist ein Algorithmus der einfach alle möglichen Wege abklappert und gewisse Dinge berücksichtigt. Danach wüsstest du vorher schon wie der Hamster laufen muss.

 

[nik_]

rucksackproblem? dachte eher an nen graphenproblem.

meine idee wäre folgende: wenn du nen pfad abläufst und an ner abzweigung (mehr als 2 mögliche wege die zu gehen sind ankommst), dann markier diesen punkt und wähle 1 weg. wenn der weg ne sackgasse ist, dann mach einen knoten ans ende, zieh ne kante und gib dieser kante hohe kosten (z.b. 100). dann müsste dein hamster zurück zum vorherigen knoten (dem an der abzweigung laufen) und von dort aus den noch nicht erforschten weg gehen usw. das wäre dann halt nen graph (auch wenn man der karte das zunächst nicht ansieht).

evtl. hilft dir der dijkstra algorightmus oder A* weiter. nur das du den graphen nicht gegeben hast, sondern während der laufzeit erstellen musst (außer das level ist bekannt, dann kann man das evtl. als graph abbilden, was aber normalerweise net der fall ist).

@ozzy. rucksackproblem ist nach meinem wissensstand folgendes: du hast nen rucksack der größe S und hast s-viele gegenstände mit v-Werten (jeder Gegenstand hat einen Wert). Die Frage beim Rucksackproblem ist die folgende: Gibt es eine Auswahl der Gegenstände, so dass s<S und v>k und k ist ein vorgegebern Wert.