void main()
{
vor();
vor();
vor();
vor();
vor();
linksUm();
linksUm();
vor();
vor();
vor();
vor();
vor();
}
void main()
{
vor();
vor();
vor();
nimm();
linksUm();
linksUm();
linksUm();
vor();
vor();
vor();
nimm();
linksUm();
linksUm();
linksUm();
vor();
vor();
vor();
nimm();
linksUm();
linksUm();
linksUm();
vor();
vor();
vor();
}
void main()
{
while (vornFrei()) vor();
linksUm();
linksUm();
while (vornFrei()) vor();
}
void main()
{
while (vornFrei()) vor();
linksUm();
linksUm();
while (kornDa()) nimm();
while (vornFrei()) vor();
while (!maulLeer()) gib();
}
void main()
{
vor();
while (vornFrei())
{
while (kornDa())
{
nimm();
}
vor();
}
nimm();
linksUm();
linksUm();
while (!kornDa()) vor();
}
void main()
{
while (!maulLeer())
{
while (vornFrei())
{
vor();
}
linksUm();
if (!maulLeer())
{
gib();
}
}
}
void main()
{
while (vornFrei())
{
vor();
if (kornDa())
{
linksUm();
nimm();
}
}
}
void main()
{
while (vornFrei())
{
if (kornDa())
{
nimm();
//Testen, ob noch weitere Körner vorhanden sind
if (kornDa())
{
nimm();
// 3 Körner: nach rechts drehen 1 Schritt vor
if (kornDa())
{
nimm();
rechtsUm();
vor();
}
else
// 2 Körner: nach links drehen 1 Schritt vor
{
linksUm();
vor();
}
}
else
// 1 Korn 1 Schritt vor
{
vor();
}
}
}
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void main()
{
while (vornFrei()) vor();
mauerAusweichen();
while (vornFrei()) vor();
mauerAusweichen();
while (vornFrei()) vor();
mauerAusweichen();
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void mauerAusweichen()
{
linksUm();
vor();
rechtsUm();
vor();
vor();
rechtsUm();
vor();
linksUm();
}
void main()
{
laufUndLege();
rechtsUm();
laufUndLege();
rechtsUm();
laufUndLege();
rechtsUm();
laufUndLege();
}
void laufUndLege()
{
while (vornFrei())
{
vor();
// auf der Kachel liegen 2 Körner
if (kornDa())
{
nimm();
}
// auf der Kachel lag nur 1 Korn -> Korn zurücklegen
if (!kornDa())
{
gib();
}
}
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void main()
{
while (kornDa())
{
reiheKoernerSammeln();
}
}
void reiheKoernerSammeln()
{
while (vornFrei())
{
while (kornDa()) nimm();
vor();
}
linksUm();
linksUm();
// in der Ecke liegen Körner
while (kornDa()) nimm();
// zurück zum Ausgangspunkt der Reihe
while (vornFrei()) vor();
linksUm();
// letzte Reihe erreicht -> nicht mehr vorgehen
if (vornFrei()) vor();
linksUm();
}
void main()
{
while (vornFrei()) vor();
// am Ende der Stufe ist nicht frei
// der Hamster kann so eine Treppe beliebiger Hoehe hinauf gehen
while (!vornFrei()) stufeHoch();
vor();
// am Ende der Stufe ist frei (ausser am Ende s. Kommentar stufeRunter() )
// der Hamster kann so eine Treppe beliebiger Hoehe hinunter gehen
while (vornFrei()) stufeRunter();
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void stufeHoch()
{
linksUm();
vor();
rechtsUm();
vor();
}
void stufeRunter()
{
rechtsUm();
// wenn das Ende der Treppe erreicht ist nicht mehr vorgehen
// Programm endet, wenn der Hamster an der rechten Wand ankommt
if (vornFrei()) vor();
linksUm();
vor();
}
void main()
{
// Startwert für anzahlSchritte setzetn
int anzahlSchritte = 1;
while (vornFrei())
{
vor();
// anzahlSchritte um 1 erhöhen
// alternativ: anzahlSchritte ++;
anzahlSchritte = anzahlSchritte + 1;
}
linksUm();
linksUm();
// anzahlSchritte rückwärts zählen
while (anzahlSchritte > 1)
{
vor();
anzahlSchritte = anzahlSchritte - 1;
}
}
void main()
{
// Startwert für anzahlKorn setzen
int anzahlKorn = 0;
while (vornFrei())
{
while (kornDa())
{
nimm();
// anzahlKorn um 1 erhöhen
anzahlKorn = anzahlKorn + 1;
}
while (anzahlKorn > 0)
{
vor();
anzahlKorn = anzahlKorn - 1;
}
}
}
void main()
{
while(!linksFrei())
{
vor();
}
}
boolean linksFrei()
{
linksUm();
boolean ist_frei = vornFrei();
rechtsUm();
return ist_frei;
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
boolean rechtsFrei()
{
rechtsUm();
if (vornFrei())
{
linksUm();
return true;
}
else
{
linksUm();
return false;
}
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void main()
{
while(!rechtsFrei())
{
vor();
}
}
void main()
{
while (vornFrei()) vor();
while (!kornDa())
{
linksUm();
while (!rechtsFrei()) vor();
rechtsUm();
vor();
vor();
rechtsUm();
while (vornFrei()) vor();
linksUm();
while (vornFrei()) vor();
}
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
boolean rechtsFrei()
{
rechtsUm();
if (vornFrei())
{
linksUm();
return true;
}
else
{
linksUm();
return false;
}
}
void main()
{
while (vornFrei())
{
/* verschachtelte if-Anweisung beginnt mit vorne
dann im else-Zweig weiter mit rechts, dann im dazugehörigen else-Zweig
links abfragen
*/
if (vornKornDa()) nimm();
else
{
if (rechtsKornDa()) nimm();
else
{
if (linksKornDa()) nimm();
}
}
}
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
// Testen, ob vorne ein Korn liegt
boolean vornKornDa()
{
vor();
if (kornDa())return true;
else
{
linksUm();
linksUm();
vor();
linksUm();
linksUm();
return false;
}
}
// Testen, ob rechts ein Korn liegt
boolean rechtsKornDa()
{
rechtsUm();
vor();
if (kornDa())return true;
else
{
linksUm();
linksUm();
vor();
rechtsUm();
return false;
}
}
// Testen, ob links ein Korn liegt
boolean linksKornDa()
{
linksUm();
vor();
if (kornDa()) return true;
else
{
linksUm();
linksUm();
vor();
linksUm();
linksUm();
return false;
}
}
void main()
{
boolean rechts = false;
boolean links = false;
while (!kornDa())
{
vor();
// T-Kreuzung
// boolean links: links abgebogen
// boolean rechts: rechts abgebogen
if (rechtsFrei() && linksFrei())
{
// links abgebogen
if (links)
{
linksUm();
vor();
links = false;
}
// rechts abgebogen
else if (rechts)
{
rechtsUm();
vor();
rechts = false;
}
}
if (linksFrei())
{
// Weg nach links und geradeaus
if (vornFrei()) links = true;
linksUm();
vor();
}
if (rechtsFrei())
{
// Weg nach links und geradeaus
if (vornFrei()) rechts = true;
rechtsUm();
vor();
}
// Sackgasse
if (!vornFrei())
{
linksUm();
linksUm();
}
}
nimm();
}
boolean linksFrei()
{
linksUm();
boolean ist_frei = vornFrei();
rechtsUm();
return ist_frei;
}
boolean rechtsFrei()
{
rechtsUm();
boolean ist_frei = vornFrei();
linksUm();
return ist_frei;
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void main()
{
int anzahlSchritte = bisZurMauer();
linksUm();
linksUm();
while (anzahlSchritte > 0)
{
vor();
anzahlSchritte=anzahlSchritte - 1;
}
}
int bisZurMauer()
{
int anzahl = 0;
while (vornFrei())
{
vor();
anzahl=anzahl + 1;
}
return anzahl;
}
void main()
{
while (!maulLeer())
{
int anzahlSchritte = zufallsZahl();
while (anzahlSchritte > 0)
{
if (vornFrei()) vor();
anzahlSchritte = anzahlSchritte - 1;
}
linksUm();
if (!maulLeer()) gib();
}
}
int zufallsZahl()
{
// maximale Zahl festlegen
int maxZahl = 4;
int zahl = 0;
zahl = (int) (Math.random() * maxZahl + 1);
return zahl;
}
void main()
{
while (vornFrei())
{
if (vornFrei()) vor();
if (rechtsFrei())
{
rechtsUm();
int anzahlSchritte = bisZurMauer();
linksUm();
linksUm();
while (anzahlSchritte > 0)
{
vor();
anzahlSchritte = anzahlSchritte - 1;
}
rechtsUm();
}
}
}
boolean rechtsFrei()
{
rechtsUm();
boolean ist_frei = vornFrei();
linksUm();
return ist_frei;
}
int bisZurMauer()
{
int anzahl = 0;
while (vornFrei())
{
vor();
anzahl = anzahl + 1;
}
return anzahl;
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void main()
{
while (anzahlKoernerImMaul() > 0)
{
int anzahlSchritte = bisZurMauer();
linksUm();
linksUm();
while (anzahlSchritte > 0)
{
vor ();
anzahlSchritte = anzahlSchritte - 1;
}
linksUm();
linksUm();
gib();
}
}
int anzahlKoernerImMaul()
{
int anzahlKoerner = 0;
while(!maulLeer())
{
gib();
anzahlKoerner=anzahlKoerner + 1;
}
int koernerAufnehmen = anzahlKoerner;
while (koernerAufnehmen > 0)
{
nimm();
koernerAufnehmen = koernerAufnehmen - 1;
}
return anzahlKoerner;
}
int bisZurMauer()
{
int anzahl = 0;
while (vornFrei())
{
vor();
anzahl = anzahl + 1;
}
return anzahl;
}
void main()
{
int zahlGeteilt = zufallsZahl();
int ergebnis = zahlGeteilt / 4;
// Zufallszahl anzeigen
while (zahlGeteilt > 0)
{
gib();
vor();
zahlGeteilt = zahlGeteilt - 1;
}
linksUm();
linksUm();
while (vornFrei()) vor();
rechtsUm();
while (vornFrei()) vor();
rechtsUm();
//Ergebnis anzeigen
switch (ergebnis)
{
case (1):
{
while(!linksFrei()) vor();
linksUm();
vor();
break;
}
case (2):
{
while(!linksFrei()) vor();
vor();
while(!linksFrei()) vor();
linksUm();
while(vornFrei()) vor();
break;
}
case (3):
{
while(!linksFrei()) vor();
vor();
while(!linksFrei()) vor();
vor();
while(!linksFrei()) vor();
linksUm();
while(vornFrei()) vor();
break;
}
case (4):
{
while(vornFrei()) vor();
linksUm();
while(vornFrei()) vor();
break;
}
}
}
boolean linksFrei()
{
linksUm();
boolean ist_frei = vornFrei();
rechtsUm();
return ist_frei;
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
int zufallsZahl()
{
int maxZahl = 16;
int zahl = (int) (Math.random() * maxZahl + 1);
// nur durch 4 teilbare Zahl
while (zahl %4 != 0)
{
zahl = (int) (Math.random() * maxZahl + 1);
}
return zahl;
}
void main()
{
int durchgang = 0;
while (durchgang < 3)
{
int anzahlKorn = zufallsZahl();
switch (anzahlKorn)
{
case (1):
{
gib();
vor();
break;
}
case (2):
{
gib();
vor();
linksUm();
vor();
gib();
linksUm();
linksUm();
vor();
linksUm();
vor();
break;
}
case (3):
{
gib();
vor();
linksUm();
vor();
gib();
vor();
rechtsUm();
vor();
linksUm();
gib();
linksUm();
vor();
linksUm();
vor();
vor();
linksUm();
vor();
vor();
break;
}
case (4):
{
gib();
vor();
gib();
linksUm();
vor();
gib();
linksUm();
vor();
gib();
linksUm();
vor();
linksUm();
vor();
vor();
break;
}
case (5):
{
gib();
vor();
linksUm();
vor();
gib();
vor();
rechtsUm();
vor();
linksUm();
gib();
linksUm();
vor();
vor();
gib();
linksUm();
vor();
vor();
linksUm();
vor();
vor();
gib();
vor();
break;
}
case (6):
{
linksUm();
gib();
vor();
gib();
vor();
gib();
rechtsUm();
vor();
gib();
rechtsUm();
vor();
gib();
vor();
gib();
linksUm();
vor();
break;
}
}
vor();
durchgang = durchgang + 1;
}
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
int zufallsZahl()
{
// maximale Zahl festlegen
int maxZahl = 6;
int zahl = 0;
zahl = (int) (Math.random() * maxZahl + 1);
return zahl;
}
void main()
{
while (vornFrei())
{
int anzahlKorn=anzahlKoernerPosition();
switch (anzahlKorn)
{
case (2):
{
linksUm();
break;
}
case (3):
{
rechtsUm();
break;
}
}
vor();
}
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
int anzahlKoernerPosition()
{
int anzahlKoerner = 0;
while(kornDa())
{
nimm();
anzahlKoerner = anzahlKoerner + 1;
}
return anzahlKoerner;
}
void main()
{
int anzahlSchritte = 0;
int anzahlDrehungen = 0;
int drehung = 0;
vor();
anzahlSchritte = anzahlKoerner();
vor();
anzahlDrehungen = anzahlKoerner();
while (drehung < anzahlDrehungen)
{
schritteVor(anzahlSchritte);
linksUm();
drehung ++;
}
}
void schritteVor(int anzahlSchritte)
{
int schrittZaehler = 0;
while (schrittZaehler < anzahlSchritte)
{
vor();
schrittZaehler = schrittZaehler+1;
}
}
int anzahlKoerner()
{
int anzahl = 0;
while (kornDa())
{
nimm();
anzahl = anzahl + 1;
}
return anzahl;
}
void main()
{
vor();
while (vornFrei())
{
int schritte = anzahlKoernerPosition();
int teiler = 0;
if (schritte %4 == 0) linksUm();
else if (schritte %2 == 0)
{
linksUm();
linksUm();
linksUm();
}
schritteVor(schritte);
}
}
void schritteVor(int schritte)
{
for (int zaehler = 1; zaehler <= schritte; zaehler ++)
{
if (vornFrei()) vor();
}
}
int anzahlKoernerPosition()
{
int anzahlKoerner = 0;
while(kornDa())
{
nimm();
anzahlKoerner = anzahlKoerner + 1;
}
int gefressenKoerner = anzahlKoerner;
return anzahlKoerner;
}
void main()
{
String satz = liesZeichenkette("Gib einen Text ein:");
String neuerSatz = rueckwaertsText(satz);
schreib(neuerSatz);
schreib(rueckwaertsText(satz));
}
String rueckwaertsText(String text)
{
int zaehler = 0;
String satz = "";
for (zaehler = text.length(); zaehler > 0; zaehler --)
{
satz = satz + text.substring(zaehler - 1, zaehler);
}
return satz;
}
void main()
{
String text = "Drei Chinesen mit dem Kontrabass";
// Text in Grossbuchstaben
text = text.toUpperCase();
schreib(text);
// Text in Kleinbuchstaben
text = text.toLowerCase();
schreib(text);
}
void main()
{
String text = "Drei Chinesen mit dem Kontrabass";
// Lösung mit replace()
String neuerText = text.replace("a","i");
neuerText = neuerText.replace("e","i");
neuerText = neuerText.replace("o","i");
neuerText = neuerText.replace("u","i");
schreib(neuerText);
// Lösung mit for
neuerText = "";
for (int zaehler = 0; zaehler < text.length(); zaehler ++)
{
// auf a e o u untersuchen
// bei einem Treffer den Buchstaben durch i ersetzen
if (text.substring(zaehler,zaehler + 1).equals("a")||text.substring(zaehler,zaehler + 1).equals("e")||text.substring(zaehler,zaehler + 1).equals("o")||text.substring(zaehler,zaehler + 1).equals("u"))
{
neuerText=neuerText + "i";
}
// aktueller Buchstabe ist kein Vokal: Buchstabe beibehalten und an den String anhängen
else
{
neuerText = neuerText + text.substring(zaehler, zaehler + 1);
}
}
schreib(neuerText);
}
void main()
{
String text = "Drei Chinesen mit dem Kontrabass saßen auf der Straße und erzählten sich was.";
schreib(text);
String neuerText = "";
String suchen = liesZeichenkette("Welches Wort soll gesucht werden?\n(Gross-/Kleinschreibung wird ignoriert)");
String ersetzen = liesZeichenkette("Wodurch soll das gesuchte Wort ersetzt werden?");
// Strings text/suchen in Grossbuchstaben umwandeln
String grossText = text.toUpperCase();
int index = grossText.indexOf(suchen.toUpperCase());
// wurde der gesuchte Text gefunden?
if (index!=-1)
{
neuerText = text.substring(0,index) + ersetzen + text.substring(index + suchen.length(),text.length());;
schreib(neuerText);
}
// gesuchter Text wurde nicht gefunden
else schreib("Das gesuchte Wort wurde nicht gefunden!");
}
void main()
{
int basis = liesZahl("Basis eingeben: ");
int exponent = liesZahl("Exponent eingeben: ");
int ergebnis = (int)Math.pow(basis, exponent);
schreib( zahlFormat(String.valueOf(ergebnis)));
}
String zahlFormat(String zahlString)
{
int zaehler = 0;
int zaehlerStelle = 1;
String formatierteZahl = "";
String ausgabeZahl = "";
// nur Zahlen mit mehr als 3 Stellen
if (zahlString.length() > 3)
{
// Zahl in Dezimalschreibweise formatieren
for (zaehler=zahlString.length();zaehler>0;zaehler--)
{
formatierteZahl = formatierteZahl + zahlString.substring(zaehler-1,zaehler);
zaehlerStelle ++;
// nach 3 Stellen ein Punkt
if (zaehlerStelle>3)
{
zaehlerStelle = 1;
formatierteZahl = formatierteZahl + ".";
}
}
}
else ausgabeZahl = zahlString;
// letztes Zeichen ist ein Punkt
if (formatierteZahl.endsWith("."))
{
formatierteZahl=formatierteZahl.substring(0,formatierteZahl.length()-1);
}
// Zahl von hinten nach vorne lesen
for (zaehler=formatierteZahl.length();zaehler>0;zaehler--)
{
ausgabeZahl = ausgabeZahl + formatierteZahl.substring(zaehler-1,zaehler);
}
return ausgabeZahl;
}
void main()
{
while (vornFrei())
{
vor();
kornNehmen();
}
}
void kornNehmen()
{
if (kornDa())
{
nimm();
kornNehmen();
}
}
void main()
{
erklimmeBerg();
}
void erklimmeBerg()
{
if (!vornFrei())
{
klettereStufeHoch();
erklimmeBerg();
}
}
void klettereStufeHoch()
{
linksUm();
vor();
rechtsUm();
vor();
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void main()
{
if (!gefunden) erkundeGang();
}
boolean gefunden = false;
void erkundeGang()
{
// T-Kreuzung
if (!gefunden && linksFrei() && rechtsFrei())
{
rechtsUm();
vor();
erkundeGang();
}
// linken Gang absuchen
if (!gefunden && linksFrei())
{
linksUm();
vor();
erkundeGang();
}
// rechten Gang absuchen
if (!gefunden && rechtsFrei())
{
rechtsUm();
vor();
erkundeGang();
}
// restlichen Gang absuchen
if (!gefunden && vornFrei())
{
vor();
erkundeGang();
}
else
{
linksUm();
linksUm();
}
if (kornDa())
{
nimm();
gefunden = true;
}
}
boolean rechtsFrei()
{
rechtsUm();
boolean ist_frei = vornFrei();
linksUm();
return ist_frei;
}
boolean linksFrei()
{
linksUm();
boolean ist_frei = vornFrei();
rechtsUm();
return ist_frei;
}
void rechtsUm()
{
linksUm();
linksUm();
linksUm();
}
void main()
{
int zahl = liesZahl("Von welcher Zahl die Fakultät berechnen?\nDie Zahl darf nicht größer als 10 sein!");
// rekursive Loesung
int ergebnis = fakultaet(zahl);
schreib(zahl+"! ergibt: "+ zahlFormat(String.valueOf(ergebnis))+" ");
// iterative Loesung mit for
ergebnis = 1;
for (int i = 1; i <= zahl; i ++)
{
ergebnis = ergebnis * i;
}
schreib(zahl+"! ergibt: "+ zahlFormat(String.valueOf(ergebnis))+" ");
}
int fakultaet(int zahl)
{
int ergebnis;
if (zahl == 0) return 1;
if (zahl == 1) return 1;
else ergebnis = zahl * fakultaet(zahl - 1);
return ergebnis;
}
String zahlFormat(String zahlString)
{
int zaehler = 0;
int zaehlerStelle = 1;
String formatierteZahl = "";
String ausgabeZahl = "";
if (zahlString.length() > 3)
{
// Zahl in Dezimalschreibweise formatieren
for (zaehler=zahlString.length();zaehler>0;zaehler--)
{
formatierteZahl = formatierteZahl + zahlString.substring(zaehler-1,zaehler);
zaehlerStelle ++;
if (zaehlerStelle > 3)
{
zaehlerStelle = 1;
formatierteZahl = formatierteZahl + ".";
}
}
}
else ausgabeZahl = zahlString;
// letztes Zeichen ist ein Punkt
if (formatierteZahl.endsWith("."))
{
formatierteZahl = formatierteZahl.substring(0,formatierteZahl.length()-1);
}
// Zahl von hinten nach vorne lesen
for (zaehler = formatierteZahl.length(); zaehler > 0;zaehler --)
{
ausgabeZahl = ausgabeZahl + formatierteZahl.substring(zaehler - 1, zaehler);
}
return ausgabeZahl;
}
void main()
{
Hamster paul = new Hamster();
paul.init(0, 0, Hamster.OST, 9);
while (paul.vornFrei()) paul.vor();
while (!paul.maulLeer()) paul.gib();
paul.linksUm();
paul.linksUm();
while (paul.vornFrei()) paul.vor();
Hamster karin = new Hamster();
karin.init(0, 4, Hamster.SUED, 0);
while (karin.kornDa()) karin.nimm();
while (karin.vornFrei()) karin.vor();
}
void main()
{
int anzahl = liesZahl("Wieviele Schritte?");
while (anzahl > 4)
{
anzahl = liesZahl("Schritte darf nicht größer als 4 sein!");
}
while (anzahl > 0)
{
if(vornFrei()) vor();
anzahl = anzahl - 1;
}
}
void main()
{
int schritte = 0;
int anzahlSchritte = liesZahl("Wieviele Schritte?");
int anzahlDrehungen = liesZahl("Wieviele Umdrehungen?");
int drehungen = anzahlDrehungen;
while (drehungen > 0)
{
schritte = anzahlSchritte;
while (schritte > 0)
{
if (vornFrei()) vor();
schritte = schritte - 1;
}
drehungen = drehungen - 1;
linksUm();
}
schreib("Ich bin insgesamt " + anzahlDrehungen * anzahlSchritte +" Schritte gegangen");
}
void main()
{
Hamster paul = new Hamster();
paul.init(0, 0, Hamster.OST, 0);
int zahl = paul.liesZahl("Von welcher Zahl die Fakultät berechnen?\nDie Zahl darf nicht größr als 10 sein!");
// rekursive Loesung
paul.schreib(zahl +"! ergibt: " + fakultaet(zahl) +" ");
// iterative Loesung
int ergebnis = 1;
for (int i = 1; i <= zahl; i++)
{
ergebnis = ergebnis * i;
}
paul.schreib(zahl +"! ergibt: " + ergebnis);
}
int fakultaet(int n)
{
int ergebnis;
// Fakultaet von 0 und 1 ergibt 1
if (n == 0) return 1;
if (n == 1) return 1;
else ergebnis = n * fakultaet(n - 1);
return ergebnis;
}
void main()
{
// Arbeitsfeld 10x3
// Positionen Spalte fuer willi und paul zufaellig bestimmen
int zufallsZahl = 9;
int spaltePositionWilli = (int) (Math.random() * zufallsZahl + 1);
int spaltePositionPaul = (int) (Math.random() * zufallsZahl + 1);
Hamster willi = new Hamster();
willi.init(1, spaltePositionWilli, Hamster.OST, 0);
Hamster paul = new Hamster();
paul.init(1, spaltePositionPaul, Hamster.OST, 0);
int spaltePaul = paul.getSpalte();
int spalteWilli = willi.getSpalte();
// willi ist rechts von paul
if (spaltePaul<spalteWilli)
{
while (spaltePaul < spalteWilli)
{
if (paul.vornFrei()) paul.vor();
spaltePaul = spaltePaul + 1;
}
}
// willi ist links von paul
else
{
paul.linksUm();
paul.linksUm();
while (spaltePaul > spalteWilli)
{
paul.vor();
spaltePaul = spaltePaul - 1;
}
}
paul.schreib("Hallo willi!");
}
void main()
{
// Arbeitsfeld 10x10
// Positionen für willi und paul zufällig bestimmen
int zufallsZahl = 9;
int spaltePositionWilli = (int) (Math.random() * zufallsZahl + 1);
int spaltePositionPaul = (int) (Math.random() * zufallsZahl + 1);
int reihePositionWilli = (int) (Math.random() * zufallsZahl + 1);
int reihePositionPaul = (int) (Math.random() * zufallsZahl + 1);
Hamster willi = new Hamster();
willi.init(reihePositionWilli, spaltePositionWilli, Hamster.OST, 0);
Hamster paul = new Hamster();
paul.init(reihePositionPaul, spaltePositionPaul, Hamster.OST, 0);
int reihePaul = paul.getReihe();
int spaltePaul = paul.getSpalte();
int reiheWilli = willi.getReihe();
int spalteWilli = willi.getSpalte();
// Reihe finden
if (reiheWilli > reihePaul)
{
paul.linksUm();
paul.linksUm();
paul.linksUm();
while (reihePaul < reiheWilli)
{
if (paul.vornFrei()) paul.vor();
reihePaul = reihePaul + 1;
}
}
else
{
paul.linksUm();
while (reihePaul > reiheWilli)
{
if (paul.vornFrei()) paul.vor();
reihePaul = reihePaul - 1;
}
}
// Spalte finden
if (spaltePaul < spalteWilli)
{
// paul kommt von oben
if (reihePositionPaul < reihePositionWilli)
{
// willi ist rechts von paul
if (spaltePositionPaul > spaltePositionWilli)
{
paul.linksUm();
paul.linksUm();
paul.linksUm();
}
// willi ist rechts von paul
else
{
paul.linksUm();
}
}
//paul kommt von unten
else
{
// willi ist links von paul
if (spaltePositionPaul > spaltePositionWilli)
{
paul.linksUm();
}
// willi ist rechts von paul
else
{
paul.linksUm();
paul.linksUm();
paul.linksUm();
}
}
while (spaltePaul < spalteWilli)
{
if (paul.vornFrei()) paul.vor();
spaltePaul = spaltePaul + 1;
}
}
else
{
// paul kommt von oben
if (reihePositionPaul < reihePositionWilli)
{
// willi ist links von paul
if (spaltePositionPaul > spaltePositionWilli)
{
paul.linksUm();
paul.linksUm();
paul.linksUm();
}
// willi ist rechts von paul
else
{
paul.linksUm();
}
}
// paul kommt von unten
else
{
// willi ist links von paul
if (spaltePositionPaul > spaltePositionWilli)
{
paul.linksUm();
}
// willi ist rechts von paul
else
{
paul.linksUm();
paul.linksUm();
paul.linksUm();
}
}
while (spaltePaul > spalteWilli)
{
paul.vor();
spaltePaul = spaltePaul - 1;
}
}
paul.schreib("Hallo willi!");
}
class AllesKoennerHamster extends Hamster
// kehrUm -> 180 Grad drehen
// bisZurMauer -> Anzahl der Schritte bis zur Mauer festestellen
// schritteVor -> eine bestimmte Anzahl von Schritten vor gehen
{
void kehrUm()
{
this.linksUm();
this.linksUm();
}
int bisZurMauer()
{
int anzahl = 0;
while (this.vornFrei())
{
this.vor();
anzahl = anzahl + 1;
}
return anzahl;
}
void schritteVor(int anzahlSchritte)
{
int schrittZaehler = 0;
while (schrittZaehler < anzahlSchritte)
{
if (this.vornFrei()) this.vor();
schrittZaehler = schrittZaehler + 1;
}
}
}
void main()
{
AllesKoennerHamster willi = new AllesKoennerHamster();
willi.init (2, 2, Hamster.OST, 0);
int anzahlSchritte = willi.bisZurMauer();
willi.kehrUm();
willi.schritteVor(anzahlSchritte/2);
}
class AllesKoennerHamster extends Hamster
{
AllesKoennerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
/* solange die mit get.Blickrichtung() ermittelte Blickrichtung des Hamsters
nicht mit der übergebenen Richtung übereinstimmt, dreht sich der Hamster
nach links
*/
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
/* reihe -> Position des gesuchten Hamsters in der Reihe
wurde im Hauptprogramm mit getReihe() ermittelt
spalte -> Position des gesuchten Hamsters in der Spalte
wurde im Hauptprogramm mit getSpalte() ermittelt
*/
// der gesuchte Hamster befindet sich unterhalb des aktuellen Hamsters
// -> Blickrichtung SUED
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
// der gesuchte Hamster befindet sich oberhalb des aktuellen Hamsters
// -> Blickrichtung NORD
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
// der Hamster geht solange vorwärts, bis er sich in der
// gleichen Reihe wie der gesuchte Hamster befindet
while (reihe!=this.getReihe())
{
this.vor();
}
// der gesuchte Hamster befindet sich links vom aktuellen Hamster
// -> Blickrichtung OST
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
// der gesuchte Hamster befindet sich rechts vom aktuellen Hamster
// -> Blickrichtung WEST
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
// der Hamster geht solange vorwärts, bis er sich in der
// gleichen Spalte wie der gesuchte Hamster befindet
while (spalte != this.getSpalte())
{
this.vor();
}
}
int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl);
}
}
void main()
{
// Zufallszahl maximale Position in Reihe/Spalte
// da das Territorium quadratisch ist, reicht eine Zufallszahl
int zufallsZahl = Territorium.getAnzahlReihen()-1;
AllesKoennerHamster paul = new AllesKoennerHamster(((int) (Math.random() * zufallsZahl + 1)),
(int) (Math.random() * zufallsZahl + 1), Hamster.OST, 0);
AllesKoennerHamster willi = new AllesKoennerHamster(((int) (Math.random() * zufallsZahl + 1)),
(int) (Math.random() * zufallsZahl + 1), Hamster.OST, 0);
willi.geheZuKachel(paul.getReihe(), paul.getSpalte());
willi.schreib("Hallo paul!");
}
class AllesKoennerHamster extends Hamster
// rechtsUm -> nach rechts drehen
// rechtsFrei -> feststellen, ob rechts frei ist
// linksFrei -> feststellen, ob links frei ist
// bisZurMauer -> Anzahl der Schritte bis zur Mauer festestellen
// kehrUm -> 180 Grad Drehung
// schritteVor -> eine bestimmte Anzahl von Schritten vor gehen
// erklimmeStufe -> Stufe mit variabler Hoehe erklimmen
{
AllesKoennerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
void rechtsUm()
{
this.kehrUm();
this.linksUm();
}
void kehrUm()
{
this.linksUm();
this.linksUm();
}
void erklimmeStufe()
{
this.linksUm();
while (!this.rechtsFrei()) vor();
this.rechtsUm();
while(this.vornFrei()) this.vor();
}
boolean rechtsFrei()
{
this.rechtsUm();
boolean ist_frei = this.vornFrei();
this.linksUm();
return ist_frei;
}
boolean linksFrei()
{
this.linksUm();
boolean ist_frei = this.vornFrei();
this.rechtsUm();
return ist_frei;
}
int bisZurMauer()
{
int anzahl = 0;
while (this.vornFrei())
{
this.vor();
anzahl = anzahl + 1;
}
return anzahl;
}
void schritteVor(int anzahlSchritte)
{
int schrittZaehler = 0;
while (schrittZaehler < anzahlSchritte)
{
if (this.vornFrei()) this.vor();
schrittZaehler = schrittZaehler + 1;
}
}
}
void main()
{
AllesKoennerHamster willi = new AllesKoennerHamster(9, 0, Hamster.OST, 0);
while (willi.vornFrei()) willi.vor();
while(!willi.kornDa()) willi.erklimmeStufe();
}
class AllesKoennerHamster extends Hamster
{
int alleinGesammelteKoerner;
static int gemeinsamGesammelteKoerner = 0;
AllesKoennerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
void sammle()
{
while(this.kornDa())
{
this.nimm();
this.alleinGesammelteKoerner = this.alleinGesammelteKoerner + 1;
this.gemeinsamGesammelteKoerner = this.gemeinsamGesammelteKoerner + 1;
}
}
void laufeUndSammle()
{
while (this.vornFrei())
{
this.vor();
this.sammle();
}
}
void mitteilung()
{
this.schreib("Wir haben zusammen "+gemeinsamGesammelteKoerner+" Körner gesammelt!");
}
}
void main()
{
AllesKoennerHamster paul = new AllesKoennerHamster(0, 0, Hamster.OST, 0);
AllesKoennerHamster karin = new AllesKoennerHamster(1, 0, Hamster.OST, 0);
AllesKoennerHamster willi = new AllesKoennerHamster(2, 0, Hamster.OST, 0);
AllesKoennerHamster heidi = new AllesKoennerHamster(3, 0, Hamster.OST, 0);
paul.laufeUndSammle();
karin.laufeUndSammle();
willi.laufeUndSammle();
heidi.laufeUndSammle();
heidi.mitteilung();
}
class AllesKoennerHamster extends Hamster
{
AllesKoennerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
// neuen Hamster mit den Attributen eines bestehenden Hamsters erzeugen
AllesKoennerHamster(Hamster existierenderHamster)
{
super(existierenderHamster);
}
void schritteVor(int anzahlSchritte)
{
while (anzahlSchritte > 0)
{
if (this.vornFrei()) this.vor();
anzahlSchritte = anzahlSchritte - 1;
}
}
void rechtsUm()
{
this.linksUm();
this.linksUm();
this.linksUm();
}
void kehrUm()
{
this.linksUm();
this.linksUm();
}
static int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl + 1);
}
}
class StaffelHamster extends AllesKoennerHamster
{
StaffelHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(1, 0, Hamster.OST, 0);
}
/* verwendete Methoden von AllesKoennerHamster:
-> schritteVor(anzahlSchritte)
-> zufallsZahl()
-> rechtsUm()
-> kehrUm()
*/
// Verwendung in staffelLauf
final static int ANZAHL_HAMSTER = 4;
// static -> gilt in der gesamten Klasse
static int anzahlSchritte;
//Subobjekt
StaffelHamster laeufer;
void lauf()
{
// Anzahl der Schritte per Zufall bestimmen
int anzahlSchritte = this.zufallsZahl(Territorium.getAnzahlSpalten() - 1);
// willi läuft einmal die Strecke ab
this.schritteVor(anzahlSchritte);
this.kehrUm();
this.schritteVor(anzahlSchritte);
while (Hamster.getAnzahlHamster() < ANZAHL_HAMSTER)
{
this.laeufer = new StaffelHamster(this.getReihe(), this.getSpalte(), Hamster.OST, 0);
this.laeufer.schritteVor(anzahlSchritte);
this.laeufer.kehrUm();
this.laeufer.schritteVor(anzahlSchritte);
}
}
}
void main()
{
/* Methoden von AllesKoennerHamster:
-> zufallsZahl()
-> schritteVor(anzahlSchritte)
-> kehrUm()
Methoden von StaffelHamster:
-> lauf()
*/
StaffelHamster willi = new StaffelHamster(1, 0, Hamster.OST, 0);
willi.lauf();
}
class NachwuchsHamster extends AllesKoennerHamster
{
/*
verwendete Methoden von AllesKoennerHamster:
-> geheZuKachel(reihe, spalte)
-> zufallszahl(maxZahl)
-> rechtsUm()
*/
// Konstante -> wird in in nachwuchs_erzeugen verwendet
final static int ANZAHL_HAMSTER = 8;
NachwuchsHamster nachwuchs;
NachwuchsHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe,spalte,blickrichtung,0);
this.nachwuchs = null;
}
void lauf()
{
// der Hamster laeuft mit der Methode geheZuKachel() von AllesKoennerHamster zu einer zufaelligen Kachel
this.geheZuKachel(this.zufallsZahl(Territorium.getAnzahlReihen() - 1), this.zufallsZahl(Territorium.getAnzahlSpalten() - 1));
// zwei Hamster auf einer Kachel
if (Territorium.getAnzahlHamster(this.getReihe(),this.getSpalte()) > 1)
{
this.nachwuchs = new NachwuchsHamster(this.getReihe(), this.getSpalte(), NachwuchsHamster.zufallsZahl(3), 0);
}
// nur wenn der aktuelle Hamster Nachwuchs (nachwuchs != null) hat, darf dieser laufen
if (this.nachwuchs != null) this.nachwuchs.lauf();
}
}
void main()
{
NachwuchsHamster willi = new NachwuchsHamster(NachwuchsHamster.zufallsZahl(Territorium.getAnzahlReihen() - 1),
NachwuchsHamster.zufallsZahl(Territorium.getAnzahlSpalten()- 1), Hamster.OST, 0);
NachwuchsHamster karin = new NachwuchsHamster(AllesKoennerHamster.zufallsZahl(Territorium.getAnzahlReihen() - 1),
NachwuchsHamster.zufallsZahl(Territorium.getAnzahlSpalten() - 1), Hamster.OST, 0);
NachwuchsHamster paul = new NachwuchsHamster(NachwuchsHamster.zufallsZahl(Territorium.getAnzahlReihen() - 1),
NachwuchsHamster.zufallsZahl(Territorium.getAnzahlSpalten() - 1), Hamster.OST, 0);
while (Hamster.getAnzahlHamster() < NachwuchsHamster.ANZAHL_HAMSTER)
{
paul.lauf();
karin.lauf();
willi.lauf();
}
}
void main()
{
AllesKoennerHamster paul = new AllesKoennerHamster(0, 0, Hamster.OST, 0);
String [] buchstaben = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
String ausgabe = "";
for (int zaehler = 0; zaehler < 10; zaehler ++)
{
/*
maximale moegliche Zahl ist die Laenge des Arrays buchstaben
den ermittelten Buchstaben dem String ausgabe hinzufuegen
*/
ausgabe = ausgabe + buchstaben[(int) (Math.random() * buchstaben.length)];
}
paul.schreib(ausgabe);
}
void main()
{
Hamster paul = new Hamster();
paul.init(0, 0, Hamster.OST, 0);
int[] zahlen = new int[10];
int gesicherteListe[] = new int[10];
String ausgabe="";
int maxZahl = 20;
// Liste zufälliger Zahlen erstellen
for (int zaehler = 0; zaehler < zahlen.length; zaehler ++ )
{
zahlen[zaehler] = (int) (Math.random() * maxZahl);
}
// Zahlen in Liste gesicherteListe kopieren
for (int zaehler = 0; zaehler < zahlen.length; zaehler++ )
{
gesicherteListe[zaehler] = zahlen[zaehler];
}
String sortierteListe = "";
String originalListe = "";
// Liste sortieren mit BubbleSort
// Zwischenspeicher: die zu tauschende Zahl wird gesichert
int tausch = 0;
// Die Liste wird von Element 0 bis zum Ende abgefragt
for (int anzahlElemente = 0; anzahlElemente < zahlen.length; anzahlElemente ++)
{
// Durchlauf der Liste für das jeweilige Elemente
for (int zaehler = 0; zaehler < zahlen.length - 1; zaehler ++ )
{
/*
ist das aktuelle Element größser als das darauf Folgende?
wenn ja: das aktuelle Element wird in der Variablen tausch gesichert
anschließend wird das aktuelle Element
zahlen[zaehler] mit dem darauf folgenden Element zahlen[zaehler+1] getauscht
zahlen[zaehler] = zahlen[zaehler + 1];
in der Variablen zahlen[zaehler + 1] steht noch der bisherige Wert
deshalb wird die gesicherte Variable tausch zahlen[zaehler] zugeweisen
*/
if (zahlen[zaehler] >= zahlen[zaehler + 1])
{
tausch = zahlen[zaehler];
zahlen[zaehler] = zahlen[zaehler + 1];
zahlen[zaehler + 1] = tausch;
}
}
}
// Liste in verschiedenen Strings speichern
for (int zaehler = 0; zaehler < zahlen.length; zaehler++)
{
originalListe = originalListe + gesicherteListe[zaehler] + ", ";
sortierteListe = sortierteListe + zahlen[zaehler]+", ";
}
paul.schreib("sortierte Liste: "+ sortierteListe+"\n\Originalliste: "+ originalListe);
}
import java.util.ArrayList;
import java.util.Random;
import java.util.Collections;
void main()
{
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
ArrayList<Integer> zahlen = new ArrayList<Integer>();
Random zufall = new Random();
int maxZahl = 20;
// Liste mit Zufallszahlen füllen
for (int zaehler = 0; zaehler < maxZahl; zaehler ++)
{
zahlen.add(zufall.nextInt(maxZahl));
}
// Originalliste in einem String sichern
String originalListe = new ArrayList<Integer>(zahlen).toString();
// Liste sortieren
Collections.sort(zahlen);
// sortierte Liste in einen String umwandeln
String sortierteListe = new ArrayList<Integer>(zahlen).toString();
paul.schreib("sortierte Liste: "+ sortierteListe+"\n\nalte Liste: "+ originalListe);
}
void main()
{
int zahl = 0;
int zaehler = 0;
int zaehler1 = 0;
int zahlen[] = new int [6];
int zahlenEingabe[] = new int [6];
String textEingabe = "";
boolean gefunden = true;
String text = "";
String hinweis = "";
int treffer = 0;
int eingegebeneZahl = 0;
int maxZahl = 0;
// maxZahl abfragen
maxZahl = liesZahl("Bitte gib die maximale Zufallszahl ein:");
// Array fuellen
while (zaehler < zahlen.length)
{
zahl = zufallsZahl(maxZahl);
gefunden = true;
while (gefunden)
{
// gibt es die Zahl schon?
// Vergleich mit den Elementen des Array zahlen[]
for (zaehler1 = 0;zaehler1 < zahlen.length;zaehler1 ++)
{
if (zahl == zahlen[zaehler1])
{
// Zahl im Array vorhanden, for verlassen
gefunden = true;
break;
}
else
{
gefunden = false;
}
}
// Zahl gibt es schon im Array, neue Zahl bestimmen
if (gefunden)
{
zahl = zufallsZahl(maxZahl);
}
}
zahlen[zaehler] = zahl;
zaehler ++;
}
// Zahlen sortieren
sortieren(zahlen);
for (zaehler=0;zaehler<zahlen.length;zaehler++)
{
text = text + " " + zahlen[zaehler];
}
schreib(text);
// Eingabe der Zahlen
zaehler = 0;
while (zaehler < zahlen.length)
{
gefunden = true;
hinweis = "";
while (gefunden)
{
eingegebeneZahl = liesZahl(hinweis + "Bitte gib die "+ (zaehler+1) + ". Zahl ein:");
// gibt es die Zahl schon?
// Vergleich mit den Elementen des Array zahlenEingabe[]
for (zaehler1 = 0;zaehler1 < zahlen.length;zaehler1 ++)
{
if (eingegebeneZahl == zahlenEingabe[zaehler1])
{
// Zahl im Array vorhanden, for verlassen
gefunden = true;
hinweis = "Die Zahl wurde schon verwendet! ";
break;
}
else
{
gefunden = false;
}
}
}
zahlenEingabe[zaehler] = eingegebeneZahl;
zaehler ++;
}
// Eingabe sortieren
sortieren(zahlenEingabe);
for (zaehler = 0;zaehler <zahlen.length;zaehler ++)
{
textEingabe = textEingabe + " " + zahlenEingabe[zaehler];
}
// Eingabe mit Zufallszahlen vergleichen
for (zaehler = 0;zaehler < zahlen.length;zaehler ++)
{
gefunden = false;
for (zaehler1 = 0;zaehler1 < zahlen.length;zaehler1 ++)
{
if (zahlenEingabe[zaehler1] == zahlen[zaehler])
{
// Zahl im Array vorhanden, for verlassen
gefunden = true;
break;
}
else
{
gefunden = false;
}
}
if (gefunden) treffer ++;
}
schreib(" " +text+"\n"+textEingabe+"\n" + treffer + " Treffer!");
}
void sortieren (int zahlen[])
{
int zaehler = 0;
// Zwischenspeicher: die zu tauschende Zahl wird gesichert
int tausch = 0;
// Die Liste wird von Element 0 bis zum Ende abgefragt
for (int anzahlElemente = 0; anzahlElemente < zahlen.length; anzahlElemente ++)
{
// Durchlauf der Liste fuer das jeweilige Element
for (zaehler = 0; zaehler < zahlen.length - 1; zaehler++ )
{
/* ist das aktuelle Element groesser als das darauf Folgende?
wenn ja: das aktuelle Element wird in der Variablen tausch gesichert
anschliessend wird das aktuelle Element
zahlen[zaehler] mit dem darauf folgenden Element zahlen[zaehler+1] getauscht
zahlen[zaehler] = zahlen[zaehler+1];
in der Variablen zahlen[zaehler+1] steht noch der bisherige Wert
deshalb wird die gesicherte Variable tausch zahlen[zaehler] zugeweisen
*/
if (zahlen[zaehler] >= zahlen[zaehler+1])
{
tausch = zahlen[zaehler];
zahlen[zaehler] = zahlen[zaehler+1];
zahlen[zaehler+1] = tausch;
}
}
}
}
int zufallsZahl(int maxZahl)
{
//int zahl;
return (int) (Math.random() * maxZahl + 1);
}
void main()
{
AllesKoennerHamster paul = new AllesKoennerHamster(0,0,Hamster.OST,0);
int maxFragen = 5;
String [] fragen = new String [maxFragen];
String [] antworten = new String [maxFragen];
String [] loesung = new String [maxFragen];
fragen [1] = "Wer erfand die Batterie?";
fragen [2] = "Wie lang ist der Rhein?";
fragen [3] = "In welcher Einheit wird elektrischer Widerstand gemessen?";
fragen [4] = "Wo liegt San Francisco?";
antworten [1] ="A Edison/B Volta";
antworten [2] ="A 1233 km/B 1945 km";
antworten [3] ="A Volt/B Ohm";
antworten [4] ="A An der Westküste der USA/B An der Ostküste der USA";
loesung [1] = "B";
loesung [2] = "A";
loesung [3] = "B";
loesung [4] = "A";
int bisherigeZahl[] = new int [maxFragen+1];
boolean durchlauf = false;
int zufallsFrage = 0;
int bisherigeFragen=0;
String antwortA;
String antwortB;
String antwortLoesung="";
while (bisherigeFragen<maxFragen-1)
{
durchlauf=false;
while (durchlauf==false)
{
zufallsFrage = paul.zufallsZahl(fragen.length -1);
for (int zaehler = 0; zaehler < bisherigeZahl.length; zaehler ++)
{
if (zufallsFrage==bisherigeZahl[zaehler])
{
if (bisherigeFragen<maxFragen - 1)
{
durchlauf = false;
break;
}
else
{
durchlauf = true;
break;
}
}
else
{
durchlauf=true;
}
}
}
bisherigeZahl[bisherigeFragen] = zufallsFrage;
bisherigeFragen++;
// Trennzeichen finden
int index=antworten[zufallsFrage].indexOf("/");
antwortA = antworten[zufallsFrage].substring(0,index);
antwortB = antworten[zufallsFrage].substring(index+1, antworten[zufallsFrage].length());
paul.schreib(fragen[zufallsFrage] + "\n" + antwortA+"\n" + antwortB);
antwortLoesung=paul.liesZeichenkette("Deine Anwort?");
if (antwortLoesung.equals(loesung[zufallsFrage])) paul.schreib("Richtig!");
else paul.schreib("Leider falsch!");
if (antwortLoesung.equals("E")) bisherigeFragen = maxFragen;
}
}
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
while (reihe != this.getReihe())
{
this.vor();
}
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.getSpalte())
{
this.vor();
}
}
void main()
{
// Anzahl der Hamster
int anzahlHamster = 4;
// Array initialisieren
int reihe[] = new int [anzahlHamster];
int spalte[] = new int [anzahlHamster];
int blickrichtung[] = new int [anzahlHamster];
int koerner[] = new int [anzahlHamster];
Hamster []familie = new Hamster[anzahlHamster];
// Zufallszahl maximale Position in Reihe/Spalte
int zufallsZahl = Territorium.getAnzahlReihen() - 1;
// Positionen in Arrays schreiben
// neue Standardhamster erzeugen
for (int zaehler=0;zaehler<anzahlHamster;zaehler=zaehler+1)
{
reihe[zaehler] = (int) (Math.random() * zufallsZahl + 1);
spalte[zaehler] = (int) (Math.random() * zufallsZahl + 1);
blickrichtung[zaehler] = (int) (Math.random() * 3);
koerner[zaehler] = (int) (Math.random() * zufallsZahl + 1);
familie[zaehler] = new Hamster(reihe[zaehler], spalte[zaehler], blickrichtung[zaehler], koerner[zaehler]);
while (!familie[zaehler].maulLeer()) familie[zaehler].gib();
}
/*
paul vom Typ AllesKoennerHamster erzeugen
Methode geheZuKachel() wird genutzt
paul hat eine zufaellige Position und Blickrichtung
*/
int blickrichtungPaul = (int) (Math.random() * zufallsZahl + 1);
AllesKoennerHamster paul = new AllesKoennerHamster((int) (Math.random() * Territorium.getAnzahlReihen()),
(int) (Math.random()*Territorium.getAnzahlSpalten()), (int) (Math.random() * 3), 0);
// Hamster suchen
for (int zaehler = 0; zaehler < anzahlHamster; zaehler ++)
{
paul.geheZuKachel(reihe[zaehler], spalte[zaehler]);
while (paul.kornDa()) paul.nimm();
}
}
class Zufall
{
int zufallsZahl(int maxZahl)
{
return (int)(Math.random() * maxZahl);
}
}
void main()
{
int maxZahl = 0;
int zaehler = 0;
int koerner = 0;
int reihePos[] = new int[11];
int spaltePos[] = new int[11];
// class Zufall
Zufall spalte = new Zufall();
Zufall reihe = new Zufall();
AllesKoennerHamster willi = new AllesKoennerHamster (1,1,0,0);
//willi nimmt Koerner auf
while (willi.kornDa()) willi.nimm();
//willi legt wahllos Körner ab
while (!willi.maulLeer())
{
zaehler = zaehler + 1;
// willi geht zufaellig zu einer Kachel und legt ein Korn ab
willi.geheZuKachel(spalte.zufallsZahl(Territorium.getAnzahlReihen()-1), spalte.zufallsZahl(Territorium.getAnzahlSpalten() - 1));
willi.gib();
// die aktuelle Reihe/Spalte wird in arrays gesichert
reihePos[zaehler] = willi.getReihe();
spaltePos[zaehler] = willi.getSpalte();
}
AllesKoennerHamster paul = new AllesKoennerHamster (spalte.zufallsZahl(Territorium.getAnzahlReihen() - 1), spalte.zufallsZahl(Territorium.getAnzahlSpalten() - 1), 0, 0);
while (zaehler != 0)
{
paul.geheZuKachel(reihePos[zaehler], spaltePos[zaehler]);
while (paul.kornDa()) paul.nimm();
zaehler = zaehler - 1;
}
}
class Zwillinge
{
int spalte;
int reihe;
int koerner;
Hamster junge;
Hamster maedchen;
Zwillinge(int reihe, int spalte, int blickrichtung, int koerner)
{
this.junge = new Hamster(reihe, spalte, blickrichtung, koerner);
this.maedchen = new Hamster(reihe, spalte, blickrichtung, koerner);
}
boolean vornFrei()
{
return this.junge.vornFrei();
}
boolean kornDa()
{
return this.junge.kornDa() && this.maedchen.kornDa();
}
boolean maulLeer()
{
return this.junge.maulLeer() && this.maedchen.maulLeer();
}
void vor()
{
this.junge.vor();
this.maedchen.vor();
}
void linksUm()
{
this.junge.linksUm();
this.maedchen.linksUm();
}
void gib()
{
this.junge.gib();
this.maedchen.gib();
}
void nimm()
{
this.junge.nimm();
this.maedchen.nimm();
}
int anzahlKoerner()
{
int anzahl = 0;
while (this.junge.kornDa())
{
this.junge.nimm();
this.maedchen.nimm();
anzahl = anzahl + 1;
}
return anzahl;
}
}
static final int MAXKOERNER = 20;
void main()
{
int maxZahl = 0;
// class Zufall verwenden
Zufall zahl = new Zufall(maxZahl);
// Zwillinge auf zufällige Position setzen, zufällige Anzahl von Körnern
Zwillinge beide = new Zwillinge(zahl.zufallsZahl(Territorium.getAnzahlReihen()-1), zahl.zufallsZahl(Territorium.getAnzahlSpalten() - 2), 0, zahl.zufallsZahl(MAXKOERNER));
// Zwillinge laufen bis zur Wand, drehen dann nach links
while(!beide.maulLeer())
{
beide.gib();
if (beide.vornFrei()) beide.vor();
else if (!beide.maulLeer()) beide.linksUm();
}
beide.linksUm();
beide.linksUm();
beide.vor();
// Anzahl der Körner feststellen
int koerner = beide.anzahlKoerner();
// Den Weg zurück gehen
// Solange laufen, bis keine Körner mehr auf der Kachel liegen
while (koerner>0)
{
if (koerner == 1 && beide.vornFrei()) beide.vor();
if (koerner == 2)
{
beide.linksUm();
beide.linksUm();
beide.linksUm();
beide.vor();
}
// Anzahl der Körner feststellen
koerner = beide.anzahlKoerner();
}
}
class Zufall
{
int zufallsZahl(int maxZahl)
{
return (int)(Math.random() * maxZahl);
}
}
class Position
{
int reihe;
int spalte;
// Reihe und Spalte zuweisen
Position(int rWert, int sWert)
{
this.reihe = rWert;
this.spalte = sWert;
}
int getReihe()
{
return this.reihe;
}
int getSpalte()
{
return this.spalte;
}
}
class GeheZuKachelHamster
{
int reihe;
int spalte;
int blickrichtung;
// Subobjekt erzeugen
// Bei jedem Sensor/Befehl muss der Name des Subobjektes einegfügt werden
Hamster hamster;
GeheZuKachelHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.hamster = new Hamster(reihe, spalte, blickrichtung, koerner);
}
void geheZuKachel(int reihe, int spalte)
{
if (reihe > this.hamster.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
while (reihe != this.hamster.getReihe())
{
this.hamster.vor();
}
if (spalte > this.hamster.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.hamster.getSpalte())
{
this.hamster.vor();
}
while (spalte != this.hamster.getSpalte())
{
this.hamster.vor();
}
}
void vor()
{
this.hamster.vor();
}
void linksUm()
{
this.hamster.linksUm();
}
void setzeBlickRichtung(int richtung)
{
while(this.hamster.getBlickrichtung() != richtung)
{
this.hamster.linksUm();
}
}
}
void main()
{
int maxZahl = 0;
int zaehler;
// class Zufall
Zufall zahl = new Zufall();
// class Position
Position posEnde = new Position(zahl.zufallsZahl(Territorium.getAnzahlReihen() - 1), zahl.zufallsZahl(Territorium.getAnzahlSpalten() - 1));
// Anzahl der Hamster
int anzahlHamster = 8;
// Array initialisieren
// class GeheZuKachelHamster
geheZuKachelHamster[] familie = new GeheZuKachelHamster[anzahlHamster];
for (zaehler = 0; zaehler < anzahlHamster; zaehler ++)
{
familie[zaehler] = new GeheZuKachelHamster(zahl.zufallsZahl(Territorium.getAnzahlReihen() - 1), zahl.zufallsZahl(Territorium.getAnzahlSpalten() - 1), zahl.zufallsZahl(4), 0);
}
for (zaehler = 0; zaehler < anzahlHamster; zaehler ++)
{
familie[zaehler].geheZuKachel(posEnde.getReihe(), posEnde.getReihe());
}
}
class Wettlauf
{
// MAXZAHL ist eine Konstante -> maximale Anzahl von Schritten
static final int MAXZAHL = 6;
/*
in jeder Runde darf jeder Hamster eine durch Zufall
bestimmte Anzahl von Schritten vorruecken
das Hamster-Array RennHamster wird uebergeben
*/
Hamster durchfuehren(Hamster[] RennHamster)
/*
Durchfuehrung des Wettlaufs
die Hamster-Funktion durchfuehren liefert als return-Wert
Hamster des Arrays, der als Erster die Mauer erreicht hat
*/
{
// es gibt noch keinen Sieger
Hamster sieger = null;
while (sieger == null)
{
// neues Objekt der Klasse Zufall erzeugen
Zufall wuerfeln = new Zufall();
for (int zaehler = 0; zaehler < RennHamster.length; zaehler++)
{
if (RennHamster[zaehler].vornFrei())
{
// wuerfeln
int anzahlSchritte = wuerfeln.zufallsZahl(MAXZAHL);
// anzahlSchritte laufen
while (anzahlSchritte > 0)
{
if (RennHamster[zaehler].vornFrei()) RennHamster[zaehler].vor();
anzahlSchritte = anzahlSchritte - 1;
}
}
// der Hamster hat die Mauer erreicht
if (!RennHamster[zaehler].vornFrei())
{
/*
Wettlauf beendet, der Variablen
sieger wird dem Hamster des Arrays mit der Nummer zaehler
zugeordnet
-> return verlaesst sofort die while-Schleife und liefert den Sieger
*/
sieger = RennHamster[zaehler];
return sieger;
}
}
}
return sieger;
}
}
class Zufall
{
int zufallsZahl(int maxZahl)
{
return (int)(Math.random() * maxZahl);
}
}
void main()
{
// Array anlegen
Hamster[] RennHamster = new Hamster[4];
RennHamster[0] = new Hamster(0, 0, Hamster.OST, 0);
RennHamster[1] = new Hamster(1, 0, Hamster.OST, 0);
RennHamster[2] = new Hamster(2, 0, Hamster.OST, 0);
RennHamster[3] = new Hamster(3, 0, Hamster.OST, 0);
// neues Objekt der Klasse Wettlauf erzeugen
Wettlauf rennen = new Wettlauf();
/*
dem Hamster sieger wird das Ergebnis des Wettlaufs zugeordnet
die Hamster-Funktion durchfuehren der Klasse Wettlauf wird aufgerufen
und das Array RennHamster übergeben
*/
Hamster sieger = rennen.durchfuehren(RennHamster);
// der Sieger darf sich einmal im Kreis drehen
sieger.linksUm();
sieger.linksUm();
sieger.linksUm();
sieger.linksUm();
}
class GedopterHamster extends Hamster
{
GedopterHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, 0);
}
public void vor()
{
/*
Hamster-Methode vor() wird überschrieben
-> Aufruf von super nötig
*/
if (this.vornFrei()) super.vor();
if (this.vornFrei()) super.vor();
if (this.vornFrei()) super.vor();
}
}
class DummerHamster extends Hamster
{
DummerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
static int schritte = 0;
public void vor()
{
/*
Hamster-Methode vor() wird überschrieben
-> Aufruf von super nötig
*/
while(schritte < Territorium.getAnzahlSpalten() - 2)
{
super.vor();
schritte = schritte + 1;
}
}
int getAnzahlSpalten()
{
return Territorium.getAnzahlSpalten();
}
}
void main()
{
// Array anlegen
Hamster[] RennHamster = new Hamster[4];
RennHamster[0] = new Hamster(0, 0, Hamster.OST, 0);
RennHamster[1] = new Hamster(1, 0, Hamster.OST, 0);
RennHamster[2] = new Hamster(2, 0, Hamster.OST, 0);
// der dumme Hamster ersetzt polymorph den Rennhamster[2]
RennHamster[2] = new DummerHamster(2, 0, Hamster.OST, 0);
RennHamster[3] = new Hamster(3, 0, Hamster.OST, 0);
// der gedopte Hamster ersetzt polymorph den Rennhamster[3]
RennHamster[3] = new GedopterHamster(3, 0, Hamster.OST, 0);
// neues Objekt der Klasse Wettlauf erzeugen
Wettlauf rennen = new Wettlauf();
/*
dem Hamster sieger wird das Ergebnis des Wettlaufs zugeordnet
die Hamster-Funktion durchfuehren der Klasse Wettlauf wird aufgerufen
und das Array RennHamster übergeben
*/
Hamster sieger = rennen.durchfuehren(RennHamster);
// der Sieger darf sich einmal im Kreis drehen!
sieger.linksUm();
sieger.linksUm();
sieger.linksUm();
sieger.linksUm();
}
class Wuerfel
{
int zufallsZahl()
{
return (int)(Math.random() * 7);
}
}
class ManipulierterWuerfel extends Wuerfel
{
int zufallsZahl()
{
// der MogelHamster wuerfelt immer 6!
return 6;
}
}
class SpielHamster extends AllesKoennerHamster
{
// ein neues Objekt wuerfel der Klasse Wuerfel wird erzeugt
Wuerfel wuerfel;
// Anzahl der Parameter muss mit der Klasse AllesKoennerHamster uebereinstimmen
SpielHamster(int reihe, int spalte, int blickrichtung, int koerner, Wuerfel w)
{
super(reihe, spalte, Hamster.OST, 0);
this.wuerfel = w;
}
/// der SpielHamster gibt den Wuerfel an den SchiedsrichterHamster
Wuerfel gibWuerfel()
{
return this.wuerfel;
}
}
class MogelHamster extends SpielHamster
{
// Anzahl der Parameter muss mit der Klasse SpielHamster uebereinstimmen
MogelHamster(int reihe, int spalte, int blickrichtung, int koerner, Wuerfel w)
{
super(reihe, spalte, Hamster.OST, koerner, w);
// der übergebene Würfel wird immer gegen den manipulierten Würfel ausgetauscht
this.wuerfel = new ManipulierterWuerfel();
}
}
class SchiedsrichterHamster extends Hamster
{
SchiedsrichterHamster(int reihe, int spalte)
{
// Anzahl der Parameter muss mit der Klasse Hamster uebereinstimmen
super(reihe, spalte, Hamster.OST, 0);
}
Wuerfel liefereWuerfel()
{
// erzeugt einen neuen Würfel
return new Wuerfel();
}
// würfelt mit dem ihm übergebenen Würfel
int zufallsZahl(Wuerfel wuerfel)
{
// würfelt mit Hilfe der Klasse Wuerfel
// der MogelHamster hat den Würfel gegen den manipulierten Würfel ausgetauscht
// Zeile 9 class MogelHamster
return wuerfel.zufallsZahl();
}
}
public void vor(int anzahlSchritte)
{
while (this.vornFrei() && anzahlSchritte > 0)
{
this.vor();
anzahlSchritte = anzahlSchritte - 1;
}
}
public void linksUm(int anzahlDrehungen)
{
while (anzahlDrehungen > 0)
{
this.linksUm();
anzahlDrehungen = anzahlDrehungen - 1;
}
}
void main()
{
SchiedsrichterHamster markus = new SchiedsrichterHamster(0, 0);
// fuer jeden Spieler wird ein neuer Wuerfel erzeugt
Wuerfel wuerfel1 = markus.liefereWuerfel();
Wuerfel wuerfel2 = markus.liefereWuerfel();
/*
die Würfel werden an die Spieler uebergeben
Wuerfel w ist bei SpielHamster und MogelHamster definiert
der MogelHamster tauscht ihn gegen den manipulierten Würfel aus
*/
SpielHamster paul = new SpielHamster(0, 0,Hamster.OST, 0, wuerfel1);
SpielHamster willi = new MogelHamster(1, 0,Hamster.OST, 0, wuerfel2);
// ein neues Subobjekt spielWuerfel der Klasse Wuerfel wird erzeugt
Wuerfel spielWuerfel;
boolean siegerPaul = false;
boolean siegerWilli = false;
while (!siegerPaul && !siegerWilli)
{
spielWuerfel = paul.gibWuerfel();
int zahlPaul = markus.zufallsZahl(spielWuerfel);
spielWuerfel = willi.gibWuerfel();
int zahlWilli = markus.zufallsZahl(spielWuerfel);
paul.schreib(" willi " + zahlWilli + " paul " + zahlPaul);
if (zahlPaul > zahlWilli)
{
// ueberschriebene Methode vor() aus AllesKoennerHamster
paul.vor(zahlPaul);
if(!paul.vornFrei()) siegerPaul = true;
}
else if (zahlWilli > zahlPaul)
{
// ueberschriebene Methode vor() aus AllesKoennerHamster
willi.vor(zahlWilli);
if(!willi.vornFrei()) siegerWilli = true;
}
// beide haben 6 gewuerfelt
else if (zahlWilli == zahlPaul)
{
// ueberschriebene Methode vor() aus AllesKoennerHamster
willi.vor(zahlWilli);
if(!willi.vornFrei()) siegerWilli = true;
paul.vor(zahlPaul);
if(!paul.vornFrei()) siegerPaul = true;
}
}
// ueberschriebene Methode linksUm() aus AllesKoennerHamster
if (siegerPaul)
{
paul.linksUm(4);
}
if (siegerWilli)
{
willi.linksUm(4);
}
}
abstract class LaufHamster extends Hamster
{
LaufHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, Hamster.OST, 0);
}
abstract void laufe();
abstract void freuen();
}
class RennHamster extends LaufHamster
{
RennHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, Hamster.OST, 0);
}
void laufe()
{
int anzahlSchritte = 0;
Zufall wuerfeln = new Zufall();
int zahl = wuerfeln.zufallsZahl(7);
while (anzahlSchritte != zahl)
{
if (this.vornFrei()) this.vor();
anzahlSchritte = anzahlSchritte + 1;
}
}
void freuen()
{
this.linksUm();
this.linksUm();
this.linksUm();
this.linksUm();
}
}
class DummerHamster extends LaufHamster
{
DummerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, Hamster.OST, 0);
}
static int anzahlSchritte = 0;
void laufe()
{
while (anzahlSchritte < Territorium.getAnzahlSpalten()-2)
{
if (this.vornFrei()) this.vor();
anzahlSchritte=anzahlSchritte + 1;
}
}
void freuen()
{
this.linksUm();
this.linksUm();
this.linksUm();
this.linksUm();
}
}
class GedopterHamster extends LaufHamster
{
GedopterHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, Hamster.OST, 0);
}
void laufe()
{
int anzahlSchritte = 0;
Zufall wuerfeln = new Zufall();
int zahl1 = wuerfeln.zufallsZahl(7);
int zahl2 = wuerfeln.zufallsZahl(7);
while (anzahlSchritte != zahl1+zahl2)
{
if (this.vornFrei()) this.vor();
anzahlSchritte = anzahlSchritte + 1;
}
}
void freuen()
{
this.linksUm();
this.linksUm();
this.linksUm();
this.linksUm();
}
}
void main()
{
RennHamster paul = new RennHamster(0, 0, Hamster.OST,0);
DummerHamster willi = new DummerHamster(1, 0, Hamster.OST,0);
GedopterHamster karl = new GedopterHamster(2, 0, Hamster.OST,0);
boolean siegerPaul = false;
boolean siegerWilli = false;
boolean siegerKarl = false;
while (!siegerPaul && !siegerWilli && !siegerKarl)
{
paul.laufe();
if (!paul.vornFrei()) siegerPaul = true;
willi.laufe();
if (!willi.vornFrei()) siegerWilli = true;
karl.laufe();
if (!karl.vornFrei()) siegerKarl = true;
}
if (siegerPaul) paul.freuen();
if (siegerWilli) willi.freuen();
if (siegerKarl) karl.freuen();
}
class AllesKoennerHamster extends Hamster
{
AllesKoennerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
AllesKoennerHamster(Hamster existierenderHamster)
{
super(existierenderHamster);
}
void kehrUm()
{
this.linksUm();
this.linksUm();
}
void rechtsUm()
{
this.kehrUm();
this.linksUm();
}
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
while (reihe!=this.getReihe())
{
this.vor();
}
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.getSpalte())
{
this.vor();
}
}
}
class Zufall
{
int zufallsZahl(int maxZahl)
{
return (int)(Math.random() * maxZahl);
}
}
abstract class VierGewinntHamster extends AllesKoennerHamster
{
VierGewinntHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, Hamster.OST, koerner);
}
abstract void lege();
abstract int anzahlKoernerReihe(int anzahlKoerner);
}
class ZufallsHamster extends VierGewinntHamster
{
boolean sieger;
ZufallsHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, Hamster.OST, koerner);
}
void lege()
{
int position = 0;
Zufall zahl = new Zufall();
this.geheZuKachel(Territorium.getAnzahlReihen() - 1, zahl.zufallsZahl(Territorium.getAnzahlSpalten()));
this.setzeBlickRichtung(Hamster.NORD);
// Anzahl der Körner in der Spalte feststellen
int reihe = anzahlKoernerReihe(position);
this.gib();
// der ZufallsHamster gewinnt
if (this.getReihe() == 0)
{
sieger = true;
this.schreib("Sieger");
return;
}
}
void freuen()
{
this.linksUm();
this.linksUm();
this.linksUm();
this.linksUm();
}
int anzahlKoernerReihe(int position)
{
while(this.kornDa()) this.vor();
return this.getReihe() + 1;
}
}
class StrategieHamster extends VierGewinntHamster
{
boolean sieger;
StrategieHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, Hamster.OST, koerner);
}
void lege()
{
int reihe [] = new int [5];
int anzahlKoerner = 0;
/*
Strategie:
- alle Spalten abgehen und Anzahl der Körner feststellen
- 3 Körner sieger true -> gewonnen
- ist in der Spalte kein Korn, 1 ablegen
kornGegeben true -> Spalten müssen nicht erneut abgelaufen werden
- wenn alle Felder mit mindestens 1 Korn belegt sind, nach Möglichkeit Feld mit 1 Korn suchen
und dort ablegen
- liegen überall 2 Körner -> Korn in der ersten Spalte ablegen
gibt dem ZufallsHamster die Möglichkeit zum Sieg
*/
boolean kornGegeben = false;
// alle Spalten abgehen und die Anzahl der Körner feststellen
for (int zaehler = 0; zaehler < Territorium.getAnzahlSpalten(); zaehler ++)
{
this.geheZuKachel(Territorium.getAnzahlReihen() - 1, zaehler);
this.setzeBlickRichtung(Hamster.NORD);
reihe[zaehler] = anzahlKoernerReihe(anzahlKoerner);
// 3 Körner -> gewonnen -> Methode lege sofort mit return verlassen
if (reihe[zaehler] == 3)
{
this.gib();
this.schreib("Sieger");
sieger = true;
return;
}
// keine Körner -> sofort legen
if (reihe[zaehler] == 0)
{
this.gib();
// kornGegeben auf true setzen-> die Spalten müssen nicht erneut abgelaufen werden
kornGegeben = true;
break;
}
}
// kornGegeben false -> erneutes Ablaufen der Spalten -> gibt es eine Spalte mit 1 Korn?
if (!kornGegeben)
{
for (int zaehler = 0; zaehler < Territorium.getAnzahlSpalten(); zaehler ++)
{
this.geheZuKachel(Territorium.getAnzahlReihen() - 1, zaehler);
this.setzeBlickRichtung(Hamster.NORD);
if (reihe[zaehler] == 1)
{
this.vor();
this.gib();
// kornGegeben auf true setzen-> die Spalten müssen nicht erneut abgelaufen werden
kornGegeben = true;
break;
}
}
}
// kornGegeben false -> erneutes Ablaufen der Spalten -> liegen überall 2 Körner?
if (!kornGegeben)
{
for (int zaehler = 0; zaehler < Territorium.getAnzahlSpalten(); zaehler ++)
{
this.geheZuKachel(Territorium.getAnzahlReihen() - 1, zaehler);
this.setzeBlickRichtung(Hamster.NORD);
if (reihe[zaehler] == 2)
{
this.vor();
this.vor();
this.gib();
kornGegeben = true;
break;
}
}
}
}
void freuen()
{
this.linksUm();
this.linksUm();
this.linksUm();
this.linksUm();
}
int anzahlKoernerReihe(int anzahlKoerner)
{
anzahlKoerner = 0;
while(this.kornDa())
{
anzahlKoerner ++;
this.vor();
}
return anzahlKoerner;
}
}
void main()
{
boolean sieger = false;
// class Zufall verwenden
Zufall zahl = new Zufall();
// wer fängt an?
int startHamster = zahl.zufallsZahl(2);
ZufallsHamster willi = new ZufallsHamster(0, 0, 0 , 8);
StrategieHamster paul = new StrategieHamster(0, 0, 0 , 8);
while (!sieger)
{
// willi fängt an
if (startHamster == 0)
{
willi.lege();
// willi hat schon gewonnen
if (!willi.sieger) paul.lege();
}
else
{
paul.lege();
// paul hat schon gewonnen
if (!paul.sieger) willi.lege();
}
if (paul.sieger) sieger = true;
if (willi.sieger) sieger = true;
}
if (paul.sieger) paul.freuen();
if (willi.sieger) willi.freuen();
}
interface LaufHamster
{
public abstract int rueckeVor();
public abstract int zufallsZahl(int maxZahl);
}
class MogelHamster extends AllesKoennerHamster implements LaufHamster
{
// anzahldrehung gilt in der gesamten Klasse
static int anzahlDrehung;
MogelHamster (int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, blickrichtung, koerner);
}
// Methoden des interfaces LaufHamster
public int rueckeVor()
{
int anzahlSchritte = 0;
int zahl = zufallsZahl(7);
while (anzahlSchritte < zahl)
{
if (this.vornFrei() && this.anzahlDrehung < 3) this.vor();
else
{
this.rechtsUm();
this.anzahlDrehung ++;
}
anzahlSchritte ++;
}
return this.anzahlDrehung;
}
public int zufallsZahl(int maxZahl)
{
return (int)(Math.random() * maxZahl);
}
}
class EhrlicherHamster extends AllesKoennerHamster implements LaufHamster
{
// anzahldrehung gilt in der gesamten Klasse
static int anzahlDrehung;
EhrlicherHamster (int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, blickrichtung, koerner);
}
// Methoden des interfaces LaufHamster
public int rueckeVor()
{
int anzahlSchritte = 0;
int zahl = zufallsZahl(3);
while (anzahlSchritte < zahl)
{
if (this.vornFrei() && this.anzahlDrehung < 3) this.vor();
else
{
this.rechtsUm();
this.anzahlDrehung ++;
}
anzahlSchritte ++;
}
return this.anzahlDrehung;
}
public int zufallsZahl(int maxZahl)
{
return (int)(Math.random() * maxZahl) + 1;
}
}
class SchlauerHamster extends AllesKoennerHamster implements LaufHamster
{
static int anzahlDrehung;
SchlauerHamster (int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, blickrichtung, koerner);
}
// Methoden des interfaces LaufHamster
public int rueckeVor()
{
if (this.anzahlDrehung < 3)
{
while(this.vornFrei()) this.vor();
this.rechtsUm();
this.anzahlDrehung ++;
}
else
{
this.rechtsUm();
this.anzahlDrehung ++;
}
return this.anzahlDrehung;
}
public int zufallsZahl(int maxZahl)
{
return (int)(Math.random() * maxZahl) + 1;
}
}
void main()
{
EhrlicherHamster willi = new EhrlicherHamster(0, 0, Hamster.OST, 0);
MogelHamster paul = new MogelHamster(0, 0, Hamster.OST, 0);
SchlauerHamster felix = new SchlauerHamster(0, 0, Hamster.OST, 0);
while (willi.anzahlDrehung < 3 && paul.anzahlDrehung < 3 && felix.anzahlDrehung < 3)
{
paul.rueckeVor();
if (paul.kornDa())
{
paul.geheZuKachel(0,0);
paul.kehrUm();
paul.anzahlDrehung = 0;
}
willi.rueckeVor();
if (willi.kornDa())
{
willi.geheZuKachel(0, 0);
willi.kehrUm();
willi.anzahlDrehung = 0;
}
felix.rueckeVor();
if (felix.kornDa())
{
felix.geheZuKachel(0, 0);
felix.kehrUm();
felix.anzahlDrehung = 0;
}
}
}
Ohne Angabe der Kachel, die kein Korn enthält
class KeinKornDaFehler extends Exception
{
KeinKornDaFehler()
{
super( "Die Kachel ist leer!");
}
String getFehlerMeldung()
{
return "Die Kachel ist leer!";
}
}
Mit Angabe der Kachel, die kein Korn enthält
class KeinKornDaFehler extends Exception
{
int reihe;
int spalte;
// Konstruktor
KeinKornDaFehler(int r, int s)
{
super("Die Kachel an der Position " + r +"/" + s + " ist leer!");
this.reihe = r;
this.spalte = s;
}
String getFehlerMeldung(int reihe, int spalte)
{
return "Die Kachel an der Position " + reihe +"/" + spalte + " ist leer!";
}
int getReihe()
{
return this.reihe;
}
int getSpalte()
{
return this.spalte;
}
}
class VorsichtigerHamster extends Hamster
{
VorsichtigerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, blickrichtung, koerner);
}
void vorsichtigesVor() throws MauerIstDaFehler
{
if(this.vornFrei())
{
this.vor();
}
else
{
throw new MauerIstDaFehler();
}
}
void vorsichtigesNimm() throws KeinKornDaFehler
{
if(this.kornDa())
{
this.nimm();
}
else
{
// mit Anzeige der Kachel
throw new KeinKornDaFehler(this.getReihe(), this.getSpalte());
// ohne Anzeige der Kachel
throw new KeinKornDaFehler();
}
}
}
void main()
{
VorsichtigerHamster paul = new VorsichtigerHamster(0, 0, Hamster.OST, 0);
try
{
while(paul.vornFrei())
{
paul.vor();
paul.vorsichtigesNimm();
}
}
catch (KeinKornDaFehler fehlerObjekt)
{
// mit Angabe der Fehlerklasse
paul.schreib(fehlerObjekt.toString());
// ohne Angabe der Fehlerklasse
paul.schreib(fehlerObjekt.getMessage());
}
finally
{
paul.linksUm();
paul.linksUm();
while(paul.vornFrei()) paul.vor();
}
}
class RechenzeichenFehltFehler extends Exception
{
}
class DivisionDurchNullFehler extends Exception
{
}
class RechnenHamster extends Hamster {
RechnenHamster(Hamster hamster)
{
super(hamster);
}
void erfrageRechenaufgaben()
{
String antwort;
do
{
this.bearbeiteRechenaufgabe();
antwort = this.liesZeichenkette("Weitere Aufgabe (j/n)?");
}
while (antwort.equals("j"));
}
void bearbeiteRechenaufgabe()
{
try
{
String aufgabe = this.liesZeichenkette("Bitte eine Rechenaufgabe eingeben!\nRechenzeichen sind: + - / *");
// ist ein Rechenzeichen vorhanden?
String rechenZeichen = this.ermittleRechenzeichen(aufgabe);
int zahl1 = this.ermittleErsteZahl(aufgabe, rechenZeichen);
int zahl2 = this.ermittleZweiteZahl(aufgabe, rechenZeichen);
int ergebnis = this.berechne(zahl1, zahl2, rechenZeichen);
// Ausgabe des Ergebnisses erfolgt nur, wenn keine Fehler aufgetreten sind
// Ausgabe ohne zahlFormat
this.schreib(String.valueOf(String.valueOf(zahl1)) + " " + rechenZeichen + " " + String.valueOf(zahl2) + " = " + String.valueOf(ergebnis));
// Ausgabe mit zahlFormat
this.schreib(zahlFormat(String.valueOf(zahl1)) + " " + rechenZeichen + " " + zahlFormat(String.valueOf(zahl2)) + " = " + zahlFormat(String.valueOf(ergebnis)));
}
catch (RechenzeichenFehltFehler fehlerObjekt)
{
this.schreib("Das Rechenzeichen fehlt!");
}
catch (DivisionDurchNullFehler fehlerObjekt)
{
this.schreib("Eine Division durch 0 ist nicht erlaubt!");
}
// Standardfehler NumberFormatException ausgeloest durch
// Integer.parseInt(zahlString)
catch (NumberFormatException fehlerObjekt)
{
this.schreib("Du hast keine Zahl eingegeben!");
}
}
int berechne(int zahl1, int zahl2, String rechenZeichen) throws DivisionDurchNullFehler
{
int ergebnis = 0;
if (rechenZeichen.equals("+"))
{
ergebnis = zahl1 + zahl2;
}
else if (rechenZeichen.equals("-"))
{
ergebnis = zahl1 - zahl2;
}
else if (rechenZeichen.equals("*"))
{
ergebnis = zahl1 * zahl2;
}
else if (rechenZeichen.equals("/"))
{
// Division durch 0 ist verboten
if (zahl2 == 0)
{
throw new DivisionDurchNullFehler();
}
ergebnis = zahl1 / zahl2;
}
return ergebnis;
}
String ermittleRechenzeichen(String aufgabe) throws RechenzeichenFehltFehler
{
int index = aufgabe.indexOf("+");
if (index >= 0)
{
return aufgabe.substring(index, index + 1);
}
index = aufgabe.indexOf("-");
if (index >= 0)
{
return aufgabe.substring(index, index + 1);
}
index = aufgabe.indexOf("*");
if (index >= 0)
{
return aufgabe.substring(index, index + 1);
}
index = aufgabe.indexOf("/");
if (index >= 0)
{
return aufgabe.substring(index, index + 1);
}
// kein Rechenzeichen gefunden
throw new RechenzeichenFehltFehler();
}
int ermittleErsteZahl(String aufgabe, String rechenZeichen)
{
int index = aufgabe.indexOf(rechenZeichen);
String zahlString = aufgabe.substring(0, index);
zahlString = buchstabenEntfernen(zahlString);
// eventuelle Leerzeichen entfernen
zahlString = zahlString.trim();
// es wird versucht den String nach int umzuwandeln
// sind keine Zahlen enthalten, wird NumberFormatException ausgeloöt
return Integer.parseInt(zahlString);
}
int ermittleZweiteZahl(String aufgabe, String rechenZeichen)
{
int index = aufgabe.indexOf(rechenZeichen);
String zahlString = aufgabe.substring(index + 1, aufgabe.length());
zahlString = buchstabenEntfernen(zahlString);
// eventuelle Leerzeichen entfernen
// es wird versucht den String nach int umzuwandeln
// sind keine Zahlen enthalten, wird NumberFormatException ausgeloest
zahlString = zahlString.trim();
return Integer.parseInt(zahlString);
}
String zahlFormat(String zahlString)
{
int zaehler = 0;
int zaehlerStelle = 1;
String formatierteZahl = "";
String ausgabeZahl = "";
// nur Zahlen mit mehr als 3 Stellen
if (zahlString.length() > 3)
{
// Zahl in Dezimalschreibweise formatieren
for (zaehler=zahlString.length();zaehler>0;zaehler--)
{
formatierteZahl = formatierteZahl + zahlString.substring(zaehler - 1, zaehler);
zaehlerStelle ++;
// nach 3 Stellen ein Punkt
if (zaehlerStelle>3)
{
zaehlerStelle = 1;
formatierteZahl = formatierteZahl + ".";
}
}
}
else ausgabeZahl = zahlString;
// letztes Zeichen ist ein Punkt
if (formatierteZahl.endsWith("."))
{
formatierteZahl = formatierteZahl.substring(0, formatierteZahl.length() - 1);
}
// Zahl von hinten nach vorne lesen
for (zaehler = formatierteZahl.length(); zaehler > 0; zaehler --)
{
ausgabeZahl = ausgabeZahl + formatierteZahl.substring(zaehler - 1, zaehler);
}
return ausgabeZahl;
}
String buchstabenEntfernen (String zahlEingabe)
{
int index = 0;
// eventuell vorhandene Buchstaben in Grossbuchstaben umwandeln
zahlEingabe = zahlEingabe.toUpperCase();
char[] alphabet = new char[26];
char buchstabe = 65;
// Array mit Grossbuchstaben fuellen
for(int i = 0; i < alphabet.length; i++, buchstabe++)
{
alphabet[i] = buchstabe;
}
// auf Grossbuchstaben ueberpruefen
for (int zaehler = 0; zaehler < alphabet.length; zaehler ++)
{
for (int zaehler1 = 0; zaehler1 < zahlEingabe.length(); zaehler1 ++)
{
index = zahlEingabe.indexOf(alphabet[zaehler]);
if(index >= 0)
{
zahlEingabe = zahlEingabe.substring(0, index) + zahlEingabe.substring(index + 1, zahlEingabe.length());
}
}
}
return zahlEingabe;
}
}
void main()
{
RechnenHamster paul = new RechnenHamster(Hamster.getStandardHamster());
paul.erfrageRechenaufgaben();
}
import java.util.ArrayList;
import java.util.Random;
import java.util.Collections;
void main()
{
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
// Listen definieren:
// -> alleZahlen Liste aller Zahlen
// -> lottoZahlen gezogene Zahlen
ArrayList alleZahlen = new ArrayList<Integer>();
ArrayList lottoZahlen = new ArrayList<Integer>();
Random zufall = new Random();
int maxZahl;
// maxZahl ermitteln
do
{
maxZahl = paul.liesZahl("Maximale Zahl: \nDie Zahl muss groesser als 10 sein!");
}
while (maxZahl < 10);
// ArrayList alleZahlen fuellen
for (int zaehler = 1; zaehler <= maxZahl; zaehler ++)
{
alleZahlen.add(zaehler);
}
// ArrayList alleZahlen in String umwandeln
String alleZahlenString = new ArrayList<Integer>(alleZahlen).toString();
// Klammer entfernen
alleZahlenString = alleZahlenString.substring(1, alleZahlenString.length() - 1);
paul.schreib("Liste der Zahlen: \n" + alleZahlenString);
int zaehler = 0;
int index;
while(zaehler < 7)
{
// Zufallszahl bestimmen
// maximale Zahl entspricht der Größe der arraylist alleZahlen
index = zufall.nextInt(alleZahlen.size());
// zu den ergebnisZahlen den Zahlwert der Lottozahlen
// an der Position index hinzufuegen
lottoZahlen.add(alleZahlen.get(index));
// Zahl an der Position index aus alleZahlen löschen
alleZahlen.remove(index);
zaehler ++;
}
// lottoZahlen sortieren
Collections.sort(lottoZahlen);
// ArrayList lottoZahlen in String umwandeln
String lottoZahlenString = new ArrayList<Integer>(lottoZahlen).toString();
// Klammer entfernen
lottoZahlenString = lottoZahlenString.substring(1, lottoZahlenString.length() - 1);
paul.schreib("Die Lottozahlen: \n" + lottoZahlenString);
}
import java.util.*;
void main()
{
AllesKoennerHamster paul = new AllesKoennerHamster(Hamster.getStandardHamster());
// ArrayList erstellen:
// Speicherung der reihe und spalte
ArrayList<Integer> reihePos = new ArrayList<Integer>();
ArrayList<Integer> spaltePos = new ArrayList<Integer>();
Random zufall = new Random();
while(!paul.maulLeer())
{
// reihe und spalte, die paul ansteuert zufaellig bestimmen
int reihe = zufall.nextInt(Territorium.getAnzahlReihen());
int spalte = zufall.nextInt(Territorium.getAnzahlSpalten());
// Methode der Klasse AllesKoennerHamster
paul.geheZuKachel(reihe, spalte);
paul.gib();
// aktuelle Position in die ArrayList schreiben
reihePos.add(reihe);
spaltePos.add(spalte);
}
AllesKoennerHamster willi = new AllesKoennerHamster(0, 0, Hamster.OST, 0);
// solange die ArrayList reihePos nicht leer ist
while(!reihePos.isEmpty())
{
// zufaellig eine der Kacheln mit Koernern ermitteln
// get holt den Wert an der Position index
int index = zufall.nextInt(reihePos.size());
int reihe = reihePos.get(index);
int spalte = spaltePos.get(index);
// die Kachel ist abgearbeitet -> wird geloescht
reihePos.remove(index);
spaltePos.remove(index);
willi.geheZuKachel(reihe, spalte);
willi.nimm();
}
}
class AllesKoennerHamster extends Hamster
/*
rechtsUm -> nach rechts drehen
kehrUm -> 180 Grad Drehung
rechtsFrei -> feststellen, ob rechts frei ist
linksFrei -> feststellen, ob links frei ist
hintenFrei -> der Hamster überprüft ob hinter ihm frei ist
gibAlle -> alle Körner ablegen
nimmAlle -> alle Körner nehmen
bisZurMauer -> Anzahl der Schritte bis zur Mauer feststellen
schritteVor -> eine bestimmte Anzahl von Schritten vor gehen
erklimmeStufe -> Stufe mit variabler Höhe erklimmen
geheZuKachel -> zu einer Kachel gehen
zufallsZahl -> Zufallszahl ermitteln
zahlFormat -> Ganzzahl mit Dezimalpunkten formatieren
*/
{
AllesKoennerHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
// neuen Hamster mit den Attributen eines bestehenden Hamsters erzeugen
AllesKoennerHamster(Hamster existierenderHamster)
{
super(existierenderHamster);
}
void rechtsUm()
{
this.kehrUm();
this.linksUm();
}
void kehrUm()
{
this.linksUm();
this.linksUm();
}
boolean rechtsFrei()
{
this.rechtsUm();
boolean ist_frei = this.vornFrei();
this.linksUm();
return ist_frei;
}
boolean linksFrei()
{
this.linksUm();
boolean ist_frei = this.vornFrei();
this.rechtsUm();
return ist_frei;
}
boolean hintenFrei()
{
this.kehrUm();
boolean ist_frei = this.vornFrei();
this.kehrUm();
return ist_frei;
}
/*
der Hamster legt alle Körner ab, die er im Maul hat
Aufruf: int anzahlKoerner = Hamstername.gibAlle(Hamstername.get.getAnzahlKoerner()
*/
int gibAlle(int anzahl)
{
int abgelegteKoerner = 0;
while (!this.maulLeer())
{
this.gib();
abgelegteKoerner = abgelegteKoerner + 1;
}
return abgelegteKoerner;
}
int nimmAlle()
{
int gesammelteKoerner = 0;
while(this.kornDa())
{
this.nimm();
gesammelteKoerner = gesammelteKoerner + 1;
}
return gesammelteKoerner;
}
int bisZurMauer()
{
int anzahl = 0;
while (this.vornFrei())
{
this.vor();
anzahl = anzahl + 1;
}
return anzahl;
}
void schritteVor(int anzahlSchritte)
{
int schrittZaehler = 0;
while (schrittZaehler < anzahlSchritte)
{
if (this.vornFrei()) this.vor();
schrittZaehler = schrittZaehler + 1;
}
}
void erklimmeStufe()
{
this.linksUm();
while (!this.rechtsFrei()) vor();
this.rechtsUm();
while(this.vornFrei()) this.vor();
}
/*
solange die mit get.Blickrichtung() ermittelte Blickrichtung des Hamsters
nicht mit der übergebenen Richtung übereinstimmt, dreht sich der Hamster
nach links
*/
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
/*
reihe -> Position des gesuchten Hamsters in der Reihe
wurde im Hauptprogramm mit getReihe() ermittelt
spalte -> Position des gesuchten Hamsters in der Spalte
wurde im Hauptprogramm mit getSpalte() ermittelt
der gesuchte Hamster befindet sich unterhalb des aktuellen Hamsters
-> Blickrichtung SUED
*/
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
/*
der gesuchte Hamster befindet sich oberhalb des aktuellen Hamsters
-> Blickrichtung NORD
*/
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
/*
der Hamster geht solange vorwärts, bis er sich in der
gleichen Reihe wie der gesuchte Hamster befindet
*/
while (reihe!=this.getReihe())
{
this.vor();
}
/*
der gesuchte Hamster befindet sich links vom aktuellen Hamster
-> Blickrichtung OST
*/
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
/*
der gesuchte Hamster befindet sich rechts vom aktuellen Hamster
-> Blickrichtung WEST
*/
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
/*
der Hamster geht solange vorwärts, bis er sich in der
gleichen Spalte wie der gesuchte Hamster befindet
*/
while (spalte != this.getSpalte())
{
this.vor();
}
}
int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl);
}
String zahlFormat(String zahlString)
{
int zaehler = 0;
int zaehlerStelle = 1;
String formatierteZahl = "";
String ausgabeZahl = "";
// nur Zahlen mit mehr als 3 Stellen
if (zahlString.length() > 3)
{
// Zahl in Dezimalschreibweise formatieren
for (zaehler=zahlString.length();zaehler>0;zaehler--)
{
formatierteZahl = formatierteZahl + zahlString.substring(zaehler-1,zaehler);
zaehlerStelle ++;
// nach 3 Stellen ein Punkt
if (zaehlerStelle>3)
{
zaehlerStelle = 1;
formatierteZahl = formatierteZahl + ".";
}
}
}
else ausgabeZahl = zahlString;
// letztes Zeichen ist ein Punkt
if (formatierteZahl.endsWith("."))
{
formatierteZahl = formatierteZahl.substring(0, formatierteZahl.length()-1);
}
// Zahl von hinten nach vorne lesen
for (zaehler = formatierteZahl.length(); zaehler > 0; zaehler --)
{
ausgabeZahl = ausgabeZahl + formatierteZahl.substring(zaehler - 1, zaehler);
}
return ausgabeZahl;
}
}
package AllesKoennerHamster;
/*
rechtsUm -> nach rechts drehen
kehrUm -> 180 Grad Drehung
rechtsFrei -> feststellen, ob rechts frei ist
linksFrei -> feststellen, ob links frei ist
hintenFrei -> der Hamster überprüft ob hinter ihm frei ist
gibAlle -> alle Körner ablegen
nimmAlle -> alle Körner nehmen
bisZurMauer -> Anzahl der Schritte bis zur Mauer feststellen
schritteVor -> eine bestimmte Anzahl von Schritten vor gehen
erklimmeStufe -> Stufe mit variabler Hoehe erklimmen
geheZuKachel -> zu einer Kachel gehen
zufallsZahl -> Zufallszahl ermitteln
zahlFormat -> Ganzzahl mit Dezimalpunkten formatieren
*/
public class AllesKoennerHamster extends Hamster
{
public AllesKoennerHamster (int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, blickrichtung, koerner);
}
// neuen Hamster mit den Attributen eines bestehenden Hamsters erzeugen
public AllesKoennerHamster(Hamster existierenderHamster)
{
super(existierenderHamster);
}
public void rechtsUm()
{
this.kehrUm();
this.linksUm();
}
public void kehrUm()
{
this.linksUm();
this.linksUm();
}
public boolean rechtsFrei()
{
this.rechtsUm();
boolean ist_frei = this.vornFrei();
this.linksUm();
return ist_frei;
}
public boolean linksFrei()
{
this.linksUm();
boolean ist_frei = this.vornFrei();
this.rechtsUm();
return ist_frei;
}
public boolean hintenFrei()
{
this.kehrUm();
boolean ist_frei = this.vornFrei();
this.kehrUm();
return ist_frei;
}
/*
der Hamster legt alle Körner ab, die er im Maul hat
Aufruf: int anzahlKoerner = Hamstername.gibAlle(Hamstername.get.getAnzahlKoerner()
*/
public int gibAlle(int anzahl)
{
int abgelegteKoerner = 0;
while (!this.maulLeer())
{
this.gib();
abgelegteKoerner = abgelegteKoerner + 1;
}
return abgelegteKoerner;
}
public int nimmAlle()
{
int gesammelteKoerner = 0;
while(this.kornDa())
{
this.nimm();
gesammelteKoerner = gesammelteKoerner + 1;
}
return gesammelteKoerner;
}
public int bisZurMauer()
{
int anzahl = 0;
while (this.vornFrei())
{
this.vor();
anzahl = anzahl + 1;
}
return anzahl;
}
public void schritteVor(int anzahlSchritte)
{
int schrittZaehler = 0;
while (schrittZaehler < anzahlSchritte)
{
if (this.vornFrei()) this.vor();
schrittZaehler = schrittZaehler + 1;
}
}
public void erklimmeStufe()
{
this.linksUm();
while (!this.rechtsFrei()) vor();
this.rechtsUm();
while(this.vornFrei()) this.vor();
}
/*
solange die mit get.Blickrichtung() ermittelte Blickrichtung des Hamsters
nicht mit der übergebenen Richtung übereinstimmt, dreht sich der Hamster
nach links
*/
private void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
public void geheZuKachel(int reihe, int spalte)
{
/*
reihe -> Position des gesuchten Hamsters in der Reihe
wurde im Hauptprogramm mit getReihe() ermittelt
spalte -> Position des gesuchten Hamsters in der Spalte
wurde im Hauptprogramm mit getSpalte() ermittelt
der gesuchte Hamster befindet sich unterhalb des aktuellen Hamsters
-> Blickrichtung SUED
*/
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
/*
der gesuchte Hamster befindet sich oberhalb des aktuellen Hamsters
-> Blickrichtung NORD
*/
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
/*
der Hamster geht solange vorwärts, bis er sich in der
gleichen Reihe wie der gesuchte Hamster befindet
*/
while (reihe!=this.getReihe())
{
this.vor();
}
/*
der gesuchte Hamster befindet sich links vom aktuellen Hamster
-> Blickrichtung OST
*/
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
/*
der gesuchte Hamster befindet sich rechts vom aktuellen Hamster
-> Blickrichtung WEST
*/
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
/*
der Hamster geht solange vorwärts, bis er sich in der
gleichen Spalte wie der gesuchte Hamster befindet
*/
while (spalte != this.getSpalte())
{
this.vor();
}
}
public int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl);
}
public String zahlFormat(String zahlString)
{
int zaehler = 0;
int zaehlerStelle = 1;
String formatierteZahl = "";
String ausgabeZahl = "";
// nur Zahlen mit mehr als 3 Stellen
if (zahlString.length() > 3)
{
// Zahl in Dezimalschreibweise formatieren
for (zaehler=zahlString.length();zaehler>0;zaehler--)
{
formatierteZahl = formatierteZahl + zahlString.substring(zaehler-1,zaehler);
zaehlerStelle ++;
// nach 3 Stellen ein Punkt
if (zaehlerStelle>3)
{
zaehlerStelle = 1;
formatierteZahl = formatierteZahl + ".";
}
}
}
else ausgabeZahl = zahlString;
// letztes Zeichen ist ein Punkt
if (formatierteZahl.endsWith("."))
{
formatierteZahl = formatierteZahl.substring(0, formatierteZahl.length()-1);
}
// Zahl von hinten nach vorne lesen
for (zaehler = formatierteZahl.length(); zaehler > 0; zaehler --)
{
ausgabeZahl = ausgabeZahl + formatierteZahl.substring(zaehler - 1, zaehler);
}
return ausgabeZahl;
}
}
import java.io.*;
import AllesKoennerHamster.AllesKoennerHamster;
import java.util.*;
class DateiSchreibenLesenHamster extends AllesKoennerHamster
{
// PrintWriter-Objekt erzeugen
PrintWriter dateiName;
DateiSchreibenLesenHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
super(reihe, spalte, blickrichtung, koerner);
}
void macheVor()
{
try
{
Random zufall = new Random();
this.dateiName = new PrintWriter(new FileWriter("weg.txt"));
while (!this.maulLeer())
{
int reihe = zufall.nextInt(Territorium.getAnzahlReihen());
/*
oder: Methode zufallsZahl der Klasse AllesKoennerHamster verwenden
int reihe = this.zufallsZahl(Territorium.getAnzahlReihen());
int spalte = this.zufallsZahl(Territorium.getAnzahlSpalten());
*/
int spalte = zufall.nextInt(Territorium.getAnzahlSpalten());
// Methode geheZuKachel() von AllesKoennerHamster
this.geheZuKachel(reihe, spalte);
// reihe und spalte in Datei schreiben
this.dateiName.println(reihe +"/" +spalte);
this.gib();
}
}
catch (Exception fehlerMeldung)
{
this.schreib("Fehler beim Lesen der Datei!");
}
}
void macheNach()
{
// ArrayList fuer reihe und spalte definieren
ArrayList<Integer> reihePos = new ArrayList<Integer>();
ArrayList<Integer> spaltePos = new ArrayList<Integer>();
try
{
FileReader dateiName = new FileReader("weg.txt");
BufferedReader zeile = new BufferedReader(dateiName);
// erste Zeile aus Datei lesen
String befehl = zeile.readLine();
while (befehl != null)
{
// gelesene Zeile trennen
int index = befehl.indexOf("/");
// nach int umwandeln
int reihe = Integer.parseInt(befehl.substring(0, index));
int spalte = Integer.parseInt(befehl.substring(index + 1, befehl.length()));
// zur ArrayList hinzufuegen
reihePos.add(reihe);
spaltePos.add(spalte);
// naechste Zeile lesen
befehl = zeile.readLine();
}
// alle Kacheln aufsuchen
for (int zaehler = 0; zaehler < reihePos.size(); zaehler ++)
{
this.geheZuKachel(reihePos.get(zaehler), spaltePos.get(zaehler));
this.nimm();
}
}
catch (Exception fehlerMeldung)
{
this.schreib("Fehler beim Lesen der Datei!");
}
finally
{
if (this.dateiName != null)
{
try
{
this.dateiName.close();
}
// die Datei kann nicht geschlossen werden
catch (Exception fehlerMeldung)
{
this.schreib("Fehler beim Schliessen der Datei!");
}
}
}
}
public void beendeArbeit()
{
if (this.dateiName != null)
{
this.dateiName.close();
}
}
}
void main()
{
DateiSchreibenLesenHamster willi = new DateiSchreibenLesenHamster(0, 0, Hamster.OST, 10);
willi.macheVor();
willi.beendeArbeit();
DateiSchreibenLesenHamster paul = new DateiSchreibenLesenHamster(0, 0, Hamster.OST, 0);
paul.macheNach();
}
import java.io.*;
public class TextDateiFilter implements FileFilter
{
private final String[] erlaubteErweiterungen = new String[] {"txt"};
public boolean accept(File datei)
{
// mit for each Dateien auf die Erweiterung txt durchsuchen
for (String erweiterung : erlaubteErweiterungen)
{
if (datei.getName().toLowerCase().endsWith(erweiterung))
{
return true;
}
}
return false;
}
}
import java.io.*;
import java.text.*;
class DateiLesenSchreiben
{
String verzeichnisLesen(String verzeichnisDurchsuchen)
{
// String-Objekt in File-Objekt umwandeln
File verzeichnis = new File(verzeichnisDurchsuchen);
// Ein File-Array anlegen, den Inhalt des Verzeichnisses mit dem Filter TextDateiFilter auslesen
File[] dateien = verzeichnis.listFiles(new TextDateiFilter());
String dateienZeigen = "Dateiname Aenderungsdatum\n_____________________________________\n ";
// mit for each das Array dateien durchlaufen
for(File zaehler : dateien)
{
if (zaehler.isDirectory())
{
dateienZeigen = dateienZeigen +"Ordner: " + zaehler.getName() + "\n";
}
else
{
// Objekt SimpleDateFormat anlegen, Datum und Uhrzeit mit SimpleDateFormat feststellen
SimpleDateFormat datumDatei = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
dateienZeigen = dateienZeigen + zaehler.getName() + "\t" + datumDatei.format(zaehler.lastModified()) + "\n";
}
}
return dateienZeigen;
}
String dateiLesen(String dateiOeffnen)
{
String dateiInhalt = "";
try
{
// String-Objekt in File-Objekt umwandeln
File datei = new File(dateiOeffnen);
// FileReader-Objekt erzeugen
FileReader dateiName = new FileReader(datei);
// BufferedReader-Objekt erzeugen
BufferedReader zeile = new BufferedReader(dateiName);
// Zeile aus Datei lesen
String befehl = zeile.readLine();
// solange lesen bis die gelesene Zeile leer ist
while (befehl != null)
{
dateiInhalt = dateiInhalt + befehl + "\n";
befehl = zeile.readLine();
}
}
catch (IOException fehlerMeldung)
{
// eventuelle Fehlermeldung wird in die Datei syserr.txt geschrieben
fehlerMeldung.printStackTrace();
}
return dateiInhalt;
}
void dateiSchreiben(String dateiSchreiben, String inhalt)
{
try
{
// String-Objekt in File-Objekt umwandeln
File datei = new File(dateiSchreiben);
// PrintWriter-Objekt erzeugen
PrintWriter dateiName;
// dem Printwriter wird das Objekt FileWriter mit dem Dateinamen uebergeben
dateiName = new PrintWriter(new FileWriter(datei));
// der Inhalt wird in die Datei geschrieben
dateiName.println(inhalt);
// die Datei wird geschlossen
dateiName.close();
}
catch (IOException fehlerMeldung)
{
// eventuelle Fehlermeldung wird in die Datei syserr.txt geschrieben
fehlerMeldung.printStackTrace();
}
}
}
/*
zugehörige Klassen:
TextDateiFilter -> setzt .txt als Filter
DateiLesenSchreiben -> zeigt ein Verzeichnis mit .txt-Dateien an, schreibt eine txt-Datei
*/
void main()
{
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
String verzeichnisName;
String auswahl = "";
DateiLesenSchreiben lesen = new DateiLesenSchreiben();
while (!auswahl.equals("e"))
{
auswahl = paul.liesZeichenkette("Was soll ich tun?\nv = Verzeichnis nach *.txt durchsuchen\n n = Textdatei anlegen\n e = Programm beenden");
/ Verzeichnis anzeigen
if (auswahl.equals("v"))
{
verzeichnisName = paul.liesZeichenkette("Welches Verzeichnis durchsuchen?");
String dateien = lesen.verzeichnisLesen(verzeichnisName);
paul.schreib(dateien);
String dateiFrage = paul.liesZeichenkette("Welche Datei oeffnen?\nDie Endung txt wird automatisch angehaengt!");
dateiFrage = verzeichnisName +"/" + dateiFrage + ".txt";
String inhaltAnzeigen = lesen.dateiLesen(dateiFrage);
paul.schreib(inhaltAnzeigen);
}
// neue Datei anlegen
if (auswahl.equals("n"))
{
verzeichnisName = paul.liesZeichenkette("In welchem Verzeichnis soll\ndie Datei gespeichert werden?");
String inhalt = paul.liesZeichenkette("Text:");
String dateiNamefestlegen = paul.liesZeichenkette("Dateiname?\nDie Endung txt wird automatisch angehaengt!");
dateiNamefestlegen = verzeichnisName + "/" +dateiNamefestlegen + ".txt";
lesen.dateiSchreiben(dateiNamefestlegen, inhalt);
}
}
}
// Pakete importieren
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
// globale Variablen
JButton vorButton;
JButton linksUmButton;
JButton kornNehmenButton;
JButton kornGebenButton;
class MausklickAbfragen implements ActionListener
{
Hamster paul;
MausklickAbfragen(Hamster neuerHamster)
{
paul = neuerHamster;
}
public void actionPerformed(ActionEvent mausKlick)
{
// getSource() -> Quelle ermitteln
// Button vorButton abfragen
if (mausKlick.getSource() == vorButton)
{
if (paul.vornFrei()) paul.vor();
}
// Button linksUmButton abfragen
if (mausKlick.getSource() == linksUmButton)
{
paul.linksUm();
}
// Button kornNehmenButton abfragen
if (mausKlick.getSource() == kornNehmenButton)
{
if (paul.kornDa()) paul.nimm();
}
// Button kornGebenButton abfragen
if (mausKlick.getSource() == kornGebenButton)
{
if (!paul.maulLeer()) paul.gib();
}
}
}
void main()
{
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
// neues Frame-Objekt erzeugen
JFrame fenster = new JFrame("Hamster-Steuerung");
/*
Verhalten des Fensters beim Klicken auf X festlegen
JFrame.EXIT_ON_ CLOSE -> Programm wird beendet
JFrame.DO_NOTHING_ON_CLOSE -> nichts tun
JFrame.DISPOSE_ON_CLOSE -> nur das aktuelle Fenster wird geschlossen
*/
fenster.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
// setLayout(new FlowLayout() -> alle Komponenten nebeneinander anordnen
fenster.setLayout(new FlowLayout());
// JButton erzeugen
vorButton = new JButton("vor");
linksUmButton = new JButton("linksUm");
kornNehmenButton = new JButton("Korn nehmen");
kornGebenButton = new JButton("Korn geben");
// ActionListener hinzufügen
vorButton.addActionListener(new MausklickAbfragen(paul));
linksUmButton.addActionListener(new MausklickAbfragen(paul));
kornNehmenButton.addActionListener(new MausklickAbfragen(paul));
kornGebenButton.addActionListener(new MausklickAbfragen(paul));
// Buttons anzeigen
fenster.add(vorButton);
fenster.add(linksUmButton);
fenster.add(kornNehmenButton);
fenster.add(kornGebenButton);
// Frame platzieren -> 100 Pixel von links/200 Pixel von oben
fenster.setLocation(100, 200);
/*
Fenstergröße automatisch anpassen
Alternative:
fenster.setSize(Breite, Hoehe);
*/
fenster.pack();
// Fenster sichtbar machen
fenster.setVisible(true);
}
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.Color;
import javax.swing.JButton;
import javax.swing.JFrame;
import AllesKoennerHamster.AllesKoennerHamster;
// oder mit class AllesKoennerHamster
import javax.swing.JOptionPane;
// Anzahl der Hamster
int anzahlHamster = 4;
// Array initialisieren
AllesKoennerHamster[] rennHamster = new AllesKoennerHamster[anzahlHamster];
// Klassenvariable -> in der gesamten Klasse gültig
static int zaehlerHamster;
class BeendeProgramm implements ActionListener
{
public void actionPerformed(ActionEvent mausKlick)
{
// Aufruf der Methode showConfirmDialog()
int eingabe = JOptionPane.showConfirmDialog(null,"Wirklich beenden?", "Ende", JOptionPane.YES_NO_CANCEL_OPTION);
if (eingabe == 0) System.exit(0);
}
}
// aktuellen zaehlerHamster holen
public int holeZaehler()
{
return zaehlerHamster;
}
// zaehlerHamster um 1 erhoehen
void setzeZaehler(int zaehlerHamster)
{
if (zaehlerHamster < rennHamster.length)
{
zaehlerHamster ++;
this.zaehlerHamster = zaehlerHamster;
}
if (zaehlerHamster == rennHamster.length) this.zaehlerHamster = 0;
}
class SchritteGehen implements ActionListener
{
public void actionPerformed(ActionEvent mausKlick)
{
// aktuellen zaehlerHamster holen
zaehlerHamster = holeZaehler();
int anzahlSchritte = (int) (Math.random() * 6) + 1;
int schrittZaehler = 0;
// Methode schritteVor von AllesKoennerHamster verwenden
rennHamster[zaehlerHamster].schritteVor(anzahlSchritte);
// es gibt einen Sieger -> Programm beenden
if (!rennHamster[zaehlerHamster].vornFrei())
{
rennHamster[zaehlerHamster].linksUm();
rennHamster[zaehlerHamster].linksUm();
rennHamster[zaehlerHamster].linksUm();
rennHamster[zaehlerHamster].linksUm();
System.exit(0);
}
// nächster Hamster -> zaehlerHamster um 1 erhöhen
setzeZaehler(zaehlerHamster);
}
}
void main()
{
for (int zaehler = 0; zaehler < anzahlHamster; zaehler = zaehler + 1)
{
rennHamster[zaehler] = new AllesKoennerHamster(zaehler, 0, Hamster.OST, 0);
}
// neuee Objekt JFrame definieren
JFrame fenster = new JFrame("Hamster-Rennen");
/*
Verhalten des Fensters beim Klicken auf X festlegen
JFrame.EXIT_ON_ CLOSE -> Programm wird beendet
JFrame.DO_NOTHING_ON_CLOSE -> nichts tun
JFrame.DISPOSE_ON_CLOSE -> nur das aktuelle Fenster wird geschlossen
*/
fenster.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
fenster.setLayout(new FlowLayout());
JButton schritteGehenButton = new JButton("N\u00E4chster Hamster");
schritteGehenButton.addActionListener(new SchritteGehen());
fenster.add(schritteGehenButton);
JButton beendeProgrammButton = new JButton("Programm beenden");
beendeProgrammButton.setBackground(Color.red);
beendeProgrammButton.addActionListener(new BeendeProgramm());
fenster.add(beendeProgrammButton);
fenster.setLocation(100, 200);
fenster.pack();
fenster.setVisible(true);
}
class SchnitzeljagdHamster extends Hamster
{
SchnitzeljagdHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
public void run()
{
while (this.vornFrei())
{
int anzahlKorn = anzahlKoernerPosition();
switch (anzahlKorn)
{
case (2):
{
this.linksUm();
break;
}
case (3):
{
this.rechtsUm();
break;
}
}
this.vor();
}
}
void rechtsUm()
{
this.linksUm();
this.linksUm();
this.linksUm();
}
int anzahlKoernerPosition()
{
int anzahlKoerner = 0;
while(this.kornDa())
{
this.nimm();
anzahlKoerner = anzahlKoerner + 1;
}
return anzahlKoerner;
}
}
void main()
{
SchnitzeljagdHamster paul = new SchnitzeljagdHamster(8, 1, Hamster.OST, 0);
paul.start();
SchnitzeljagdHamster willi = new SchnitzeljagdHamster(8, 6, Hamster.OST, 0);
willi.start();
}
class BarrikadeHamster extends Hamster
{
boolean zurueck = false;
BarrikadeHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
this.zurueck = false;
}
public void run()
{
int maxZahl = 3;
while (this.vornFrei())
{
int anzahlSchritte = zufallsZahl(maxZahl);
// die aktuelle Spalte des Hamsters holen und sichern
// wird für die Rückkehr nch erfolglosen Würfeln gebraucht
int vorherigeSpalte = holeSpalte();
schritteVor(anzahlSchritte);
// zurueck -> true: Korn nicht mit einem Wurf getroffen, der Hamster muss zurück
if (zurueck)
{
this.geheZuSpalte(vorherigeSpalte);
this.setzeBlickRichtung(Hamster.OST);
}
zurueck = false;
}
}
void schritteVor(int anzahlSchritte)
{
int schrittZaehler = 0;
while (schrittZaehler < anzahlSchritte)
{
if (this.vornFrei()) this.vor();
schrittZaehler = schrittZaehler + 1;
/*
auf der aktuellen Position liegt ein Korn, es wurde aber mit dem Wurf nicht genau getroffen
schrittZaehler < anzahlSchritte
-> zurueck wird auf true gesetzt
-> der aktuelle Schleifendurchlauf wird mit break unterbrochen
*/
if (this.kornDa() && schrittZaehler < anzahlSchritte)
{
zurueck = true;
break;
}
}
if (this.kornDa() && !zurueck) this.nimm();
}
// aktuellen Wert für spalte holen
int holeSpalte()
{
int vorherigeSpalte = this.getSpalte();
return vorherigeSpalte;
}
void rechtsUm()
{
this.kehrUm();
this.linksUm();
}
void kehrUm()
{
this.linksUm();
this.linksUm();
}
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuSpalte(int spalte)
{
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.getSpalte())
{
this.vor();
}
}
int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl + 1);
}
}
void main()
{
BarrikadeHamster willi = new BarrikadeHamster(0, 0, Hamster.OST, 0);
willi.start();
BarrikadeHamster paul = new BarrikadeHamster(1, 0, Hamster.OST, 0);
paul.start();
}
class BarrikadeSpielHamster extends Hamster
{
boolean zurueck = false;
BarrikadeSpielHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
this.zurueck = false;
}
public void run()
{
int maxZahl = 4;
while (this.vornFrei())
{
int anzahlSchritte = zufallsZahl(maxZahl);
// die aktuelle Spalte des Hamsters holen und sichern
// wird für die Rückkehr nch erfolglosen Würfeln gebraucht
int vorherigeSpalte = holeSpalte();
int vorherigeReihe = holeReihe();
schritteVor(anzahlSchritte);
// zurueck -> true: Korn nicht mit einem Wurf getroffen, der Hamster muss zurück
if (zurueck)
{
this.geheZuKachel(vorherigeReihe, vorherigeSpalte);
this.setzeBlickRichtung(Hamster.OST);
}
zurueck = false;
}
}
void schritteVor(int anzahlSchritte)
{
int schrittZaehler = 0;
while (schrittZaehler < anzahlSchritte)
{
if (this.vornFrei()) this.vor();
schrittZaehler ++;
/*
auf der aktuellen Position liegt ein Korn, es wurde aber mit dem Wurf nicht genau getroffen
schrittZaehler < anzahlSchritte
-> zurueck wird auf true gesetzt
-> der aktuelle Schleifendurchlauf wird mit break unterbrochen
*/
if (this.kornDa() && schrittZaehler < anzahlSchritte)
{
zurueck = true;
break;
}
}
if (this.kornDa() && !zurueck)
{
this.nimm();
// jetzige Position sichern
int vorherigeSpalte = holeSpalte();
int vorherigeReihe = holeReihe();
// Hindernis für anderen Hamster setzem
if (this.getReihe() == 0)
{
this.geheZuKachel(1, Territorium.getAnzahlSpalten() - 1);
this.setzeBlickRichtung(Hamster.WEST);
while (this.getSpalte() < Territorium.getAnzahlSpalten() - 1) this.vor();
// zurueck ist false -> Barrikade für den anderen Hamster setzen
if (!zurueck)
{
if (this.kornDa() && this.getSpalte() == Territorium.getAnzahlSpalten() - 1)
{
while (this.kornDa()) this.vor();
}
/*
wenn der zweite Hamster schon da ist -> kein Korn ablegen
es kann passieren, dass der kornlegende Hamster wegen des parallelen Ablaufs
den anderen Hamster "übersieht" und trotzdem auf der nächsten Kachel ein Korn ablegt
*/
if (Territorium.getAnzahlHamster(this.getReihe(),this.getSpalte()) == 1) this.gib();
// zur alten Position zurückkehren
this.geheZuKachel(vorherigeReihe, vorherigeSpalte);
this.setzeBlickRichtung(Hamster.OST);
}
}
zurueck = false;
}
}
// aktuellen Wert für spalte holen
int holeSpalte()
{
int vorherigeSpalte = this.getSpalte();
return vorherigeSpalte;
}
// aktuellen Wert für Reihe holen
int holeReihe()
{
int vorherigeReihe = this.getReihe();
return vorherigeReihe;
}
void rechtsUm()
{
this.kehrUm();
this.linksUm();
}
void kehrUm()
{
this.linksUm();
this.linksUm();
}
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
while (reihe!=this.getReihe())
{
this.vor();
}
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.getSpalte())
{
this.vor();
}
}
int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl);
}
}
void main()
{
BarrikadeSpielHamster willi = new BarrikadeSpielHamster(0, 0, Hamster.OST, 0);
willi.start();
BarrikadeSpielHamster paul = new BarrikadeSpielHamster(1, 0, Hamster.OST, 0);
paul.start();
}
class KornFindHamster extends Hamster
{
KornFindHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
public void run()
{
while (this.maulLeer())
{
int spalte = this.zufallsZahl(Territorium.getAnzahlSpalten());
int reihe = this.zufallsZahl(Territorium.getAnzahlReihen());
this.geheZuKachel(reihe, spalte);
if (this.kornDa()) break;
}
}
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
while (reihe!=this.getReihe())
{
this.vor();
}
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.getSpalte())
{
this.vor();
}
}
int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl);
}
}
void main()
{
KornFindHamster paul = new KornFindHamster(0, 0, Hamster.OST, 0);
// Anzahl der zu verteilenden Körner
int koernerMax = ((Territorium.getAnzahlReihen() -1) * (Territorium.getAnzahlSpalten() - 1));
int verteilenKoerner = koernerMax;
// solange fragen bis die Anzahl der zu verteilenden Körner kleiner als koernermax ist
while (verteilenKoerner >= koernerMax) verteilenKoerner = paul.liesZahl("Anzahl der Koerner?\nmaximal " + (koernerMax - 1));
// maximale Anzahl der LaufHamster
int anzahlHamsterMax = 5;
int anzahlHamster = anzahlHamsterMax;
// Anzahl der Zufallshamster im Feld
while (anzahlHamster >= anzahlHamsterMax) anzahlHamster = paul.liesZahl("Anzahl der Hamster im Feld? \nMaximal " + (anzahlHamsterMax -1));
// willi wird initialisiert und verteilt die Körner
KornFindHamster willi = new KornFindHamster(Territorium.getAnzahlReihen() - 1, Territorium.getAnzahlSpalten() - 1, Hamster.OST, verteilenKoerner);
while (!willi.maulLeer())
{
int spalte = willi.zufallsZahl(Territorium.getAnzahlSpalten());
int reihe = willi.zufallsZahl(Territorium.getAnzahlReihen());
willi.geheZuKachel(reihe, spalte);
if (!willi.kornDa()) willi.gib();
}
// willi geht in die linke untere Ecke
willi.geheZuKachel(Territorium.getAnzahlReihen() - 1, 0);
// Array definieren
KornFindHamster[] zufallsHamster = new KornFindHamster[anzahlHamster];
// Hamster des Arrays initialsieren und starten
for (int zaehler = 0; zaehler < anzahlHamster; zaehler ++)
{
zufallsHamster[zaehler] = new KornFindHamster(Territorium.getAnzahlReihen() - 1, Territorium.getAnzahlSpalten() - 1, Hamster.OST, 0);
zufallsHamster[zaehler].start();
}
}
class KornFindHamster extends Hamster
{
// Instanzenattribut - wird für jeden Hamster neu initialisiert
int alleinGesammelteKoerner;
// Klassenattribut - gehört allen Hamstern gemeinsam
static int gemeinsamGesammelteKoerner = 0;
static int verteilenKoerner;
KornFindHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
this.alleinGesammelteKoerner = 0;
}
public void run()
{
boolean programmEnde = true;
int verteilenKoerner = this.getKoernerMax();
while (this.gemeinsamGesammelteKoerner != verteilenKoerner)
{
int spalte = this.zufallsZahl(Territorium.getAnzahlSpalten());
int reihe = this.zufallsZahl(Territorium.getAnzahlReihen());
this.geheZuKachel(reihe, spalte);
while (this.kornDa())
{
this.nimm();
this.alleinGesammelteKoerner ++;
this.gemeinsamGesammelteKoerner ++;
}
if (this.gemeinsamGesammelteKoerner == verteilenKoerner)
{
this.schreib("Ich habe "+ alleinGesammelteKoerner + " von " + verteilenKoerner + " gefressen!" );
break;
}
}
}
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
while (reihe!=this.getReihe())
{
this.vor();
}
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.getSpalte())
{
this.vor();
}
}
int zufallsZahl(int maxZahl)
{
return (int) (Math.random() * maxZahl);
}
// Wert für verteilenKoerner speichern
void setKoernerMax(int verteilenKoerner)
{
this.verteilenKoerner = verteilenKoerner;
}
// aktuellen Wert für verteilenKoerner holen
int getKoernerMax()
{
return verteilenKoerner;
}
}
void main()
{
KornFindHamster paul = new KornFindHamster(0, 0, Hamster.OST, 0);
// Anzahl der zu verteilenden Körner
int koernerMax = ((Territorium.getAnzahlReihen() -1) * (Territorium.getAnzahlSpalten() - 1));
int verteilenKoerner = koernerMax;
// solange fragen bis die Anzahl der zu verteilenden Körner kleiner als koernermax ist
while (verteilenKoerner >= koernerMax) verteilenKoerner = paul.liesZahl("Anzahl der Koerner?\nmaximal " + (koernerMax - 1));
// maximale Anzahl der LaufHamster
int anzahlHamsterMax = 7;
int anzahlHamster = anzahlHamsterMax;
// Anzahl der Zufallshamster im Feld
while (anzahlHamster >= anzahlHamsterMax) anzahlHamster = paul.liesZahl("Anzahl der Hamster im Feld? \nMaximal " + (anzahlHamsterMax -1));
// willi wird initialisiert und verteilt die Körner
KornFindHamster willi = new KornFindHamster(Territorium.getAnzahlReihen() - 1, Territorium.getAnzahlSpalten() - 1, Hamster.OST, verteilenKoerner);
willi.setKoernerMax(verteilenKoerner);
while (!willi.maulLeer())
{
int spalte = willi.zufallsZahl(Territorium.getAnzahlSpalten());
int reihe = willi.zufallsZahl(Territorium.getAnzahlReihen());
willi.geheZuKachel(reihe, spalte);
if (!willi.kornDa()) willi.gib();
}
// willi geht in die linke untere Ecke
willi.geheZuKachel(Territorium.getAnzahlReihen() - 1, 0);
// Array definieren
KornFindHamster[] zufallsHamster = new KornFindHamster[anzahlHamster];
// Hamster des Arrays initialsieren und starten
for (int zaehler = 0; zaehler < anzahlHamster; zaehler ++)
{
zufallsHamster[zaehler] = new KornFindHamster(Territorium.getAnzahlReihen() - 1, Territorium.getAnzahlSpalten() - 1, Hamster.OST, 0);
zufallsHamster[zaehler].start();
}
}
// Pakete importieren
import java.awt.FlowLayout;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.Color;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JFrame;
import javax.swing.ImageIcon;
import javax.swing.Icon;
import javax.swing.border.*;
import java.awt.Dimension;
// globale Variablen
JButton vorButton;
JButton linksUmButton;
JButton rechtsUmButton;
JButton kornNehmenButton;
JButton kornGebenButton;
JButton zurWandButton;
JButton beendeProgrammButton;
JLabel aktionBeschreibung;
class MausklickAbfragen implements MouseListener
{
// Hamster paul bekanntmachen
Hamster paul;
MausklickAbfragen(Hamster neuerHamster)
{
paul = neuerHamster;
}
/*
alle Methoden von MouseListener müssen überschrieben werden:
mousePressed, mouseClicked, mouseExited, mouseReleased, mouseEntered
*/
public void mousePressed(MouseEvent mausAktion){}
public void mouseClicked(MouseEvent mausAktion)
{
// Button vorButton abfragen
if (mausAktion.getSource() == vorButton)
{
if (paul.vornFrei()) paul.vor();
}
// Button linksUmButton abfragen
if (mausAktion.getSource() == linksUmButton)
{
paul.linksUm();
}
// Button rechtsUmButton abfragen
if (mausAktion.getSource() == rechtsUmButton)
{
paul.linksUm();
paul.linksUm();
paul.linksUm();
}
// Button zurWandGehenButton abfragen
if (mausAktion.getSource() == zurWandButton)
{
while(paul.vornFrei()) paul.vor();
}
// Button kornNehmenButton abfragen
if (mausAktion.getSource() == kornNehmenButton)
{
while(paul.kornDa()) paul.nimm();
}
// Button kornGebenButton abfragen
if (mausAktion.getSource() == kornGebenButton)
{
while(!paul.maulLeer()) paul.gib();
}
// Button beendeProgrammButton abfragen
if (mausAktion.getSource() == beendeProgrammButton)
{
System.exit(0);
}
}
public void mouseExited(MouseEvent mausAktion)
{
aktionBeschreibung.setText("");
}
public void mouseReleased(MouseEvent mausAktion){}
// Text beim Überfahren des Buttons anzeigen
public void mouseEntered(MouseEvent mausIn)
{
if (mausIn.getSource() == vorButton)
{
aktionBeschreibung.setText("vor");
}
if (mausIn.getSource() == linksUmButton)
{
aktionBeschreibung.setText("nach links drehen");
}
if (mausIn.getSource() == rechtsUmButton)
{
aktionBeschreibung.setText("nach rechts drehen");
}
if (mausIn.getSource() == kornNehmenButton)
{
aktionBeschreibung.setText("alle Körner nehmen");
}
if (mausIn.getSource() == kornGebenButton)
{
aktionBeschreibung.setText("alle Körner abgeben");
}
if (mausIn.getSource() == zurWandButton)
{
aktionBeschreibung.setText("zur Wand laufen");
}
if (mausIn.getSource() == beendeProgrammButton)
{
aktionBeschreibung.setText("Programm beenden");
}
}
}
void main()
{
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
// neues Frame-Objekt erzeugen
JFrame fenster = new JFrame("Hamster-Steuerung");
/*
Verhalten des Fensters beim Klicken auf X festlegen
JFrame.EXIT_ON_ CLOSE -> Programm wird beendet
JFrame.DO_NOTHING_ON_CLOSE -> nichts tun
JFrame.DISPOSE_ON_CLOSE -> nur das aktuelle Fenster wird geschlossen
*/
fenster.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
fenster.setLayout(new FlowLayout());
// JButtons erzeugen
// vor
Icon vor = new ImageIcon("start.gif");
vorButton = new JButton("", vor);
vorButton.setToolTipText("vor");
// links
Icon links = new ImageIcon("links.gif");
linksUmButton = new JButton("", links);
// rechts
Icon rechts = new ImageIcon("rechts.gif");
rechtsUmButton = new JButton("", rechts);;
// zur Wand
Icon wand = new ImageIcon("wand.gif");
zurWandButton = new JButton("", wand);
// Korn nehmen
Icon kornNehmen = new ImageIcon("korn_nehmen.png");
kornNehmenButton = new JButton("", kornNehmen);
// Korn geben
Icon kornGeben = new ImageIcon("korn_geben.png");
kornGebenButton = new JButton("", kornGeben);
// Programm beenden
Icon stop = new ImageIcon("stop.gif");
beendeProgrammButton = new JButton("", stop);
// Text bei Maus im Button
aktionBeschreibung = new JLabel("");
aktionBeschreibung.setPreferredSize(new Dimension(175, 40));
aktionBeschreibung.setBackground(Color.yellow);
aktionBeschreibung.setOpaque(true);
aktionBeschreibung.setBorder(new BevelBorder(BevelBorder.LOWERED));
aktionBeschreibung.setHorizontalAlignment(JLabel.CENTER);
// Buttons und Label anzeigen
fenster.add(vorButton);
fenster.add(linksUmButton);
fenster.add(rechtsUmButton);
fenster.add(zurWandButton);
fenster.add(kornNehmenButton);
fenster.add(kornGebenButton);
fenster.add(beendeProgrammButton);
fenster.add(aktionBeschreibung);
// MouseListener hinzufügen
// Hamster paul wird als Variable übergeben
vorButton.addMouseListener(new MausklickAbfragen(paul));
linksUmButton.addMouseListener(new MausklickAbfragen(paul));
rechtsUmButton.addMouseListener(new MausklickAbfragen(paul));
kornNehmenButton.addMouseListener(new MausklickAbfragen(paul));
kornGebenButton.addMouseListener(new MausklickAbfragen(paul));
zurWandButton.addMouseListener(new MausklickAbfragen(paul));
beendeProgrammButton.addMouseListener(new MausklickAbfragen(paul));
// Frame platzieren -> 100 Pixel von links/200 Pixel von oben
fenster.setLocation(100, 200);
/*
Fenstergroesse automatisch anpassen
Alternative:
fenster.setSize(Breite, Hoehe);
*/
fenster.pack();
// Fenster sichtbar machen
fenster.setVisible(true);
}
/*
Beispiel JLabel/JButtonGroup
JButtonGroup dient zur Gruppierung von Schaltflächen.
nur ein Element der Gruppe kann ausgewählt werden
*/
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.Color;
import javax.swing.JLabel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JToggleButton;
import javax.swing.ButtonGroup;
// globale Variablen
JLabel frageSchritte;
JButton beendeProgrammButton;
ButtonGroup buttonGruppe;
JToggleButton button1;
JToggleButton button2;
JToggleButton button3;
class MausklickAbfragen implements ActionListener
{
// Hamster paul bekanntmachen
Hamster paul;
MausklickAbfragen(Hamster neuerHamster)
{
paul = neuerHamster;
}
public void actionPerformed(ActionEvent mausKlick)
{
// getSource() -> Quelle ermitteln
// Button beendeProgrammButton abfragen
if (mausKlick.getSource() == beendeProgrammButton)
{
System.exit(0);
}
// Button 1 Schritt abfragen
if (mausKlick.getSource() == button1)
{
if (paul.vornFrei()) paul.vor();
else
{
paul.linksUm();
paul.linksUm();
}
}
// Button 2 Schritte abfragen
if (mausKlick.getSource() == button2)
{
int anzahlSchritte = 2;
while (anzahlSchritte > 0)
{
if (paul.vornFrei()) paul.vor();
if (!paul.vornFrei())
{
paul.linksUm();
paul.linksUm();
}
anzahlSchritte --;
}
}
// Button 3 Schritte abfragen
if (mausKlick.getSource() == button3)
{
int anzahlSchritte = 3;
while (anzahlSchritte > 0)
{
if (paul.vornFrei()) paul.vor();
if (!paul.vornFrei())
{
paul.linksUm();
paul.linksUm();
}
anzahlSchritte --;
}
}
// Selektion aufheben
buttonGruppe.clearSelection();
}
}
void main()
{
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
// neues Frame-Objekt erzeugen
JFrame fenster = new JFrame("Schritte gehen");
/*
Verhalten des Fensters beim Klicken auf X festlegen
JFrame.EXIT_ON_ CLOSE -> Programm wird beendet
JFrame.DO_NOTHING_ON_CLOSE -> nichts tun
JFrame.DISPOSE_ON_CLOSE -> nur das aktuelle Fenster wird geschlossen
*/
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fenster.setLayout(new FlowLayout());
// neues Objekt von JLabel erzeugen
frageSchritte = new JLabel("Wie viele Schritte?");
/*
JLabel ist transparent als Standard
-> setOpaque auf true setzen
*/
frageSchritte.setOpaque(true);
frageSchritte.setBackground(Color.yellow);
fenster.add(frageSchritte);
// neue Buttongruppe
buttonGruppe = new ButtonGroup();
button1 = new JToggleButton("1");
buttonGruppe.add(button1);
fenster.add(button1);
// ActionListener hinzufügen
button1.addActionListener(new MausklickAbfragen(paul));
button2 = new JToggleButton("2");
buttonGruppe.add(button2);
fenster.add(button2);
// ActionListener hinzufügen
button2.addActionListener(new MausklickAbfragen(paul));
button3 = new JToggleButton("3");
buttonGruppe.add(button3);
fenster.add(button3);
// ActionListener hinzufügen
button3.addActionListener(new MausklickAbfragen(paul));
// neues Objekt von JButton erzeugen
beendeProgrammButton = new JButton("Programm beenden");
beendeProgrammButton.setBackground(Color.red);
fenster.add(beendeProgrammButton);
// ActionListener hinzufügen
beendeProgrammButton.addActionListener(new MausklickAbfragen(paul));
// Frame platzieren -> 100 Pixel von links/200 Pixel von oben
fenster.setLocation(100, 200);
/*
Fenstergroesse automatisch anpassen
Alternative:
fenster.setSize(Breite, Hoehe);
*/
fenster.pack();
// Fenster sichtbar machen
fenster.setVisible(true);
}
// Pakete importieren
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.Color;
import javax.swing.JButton;
import javax.swing.JFrame;
public class ButtonsKonstruktor extends JFrame implements ActionListener
{
// globale Variablen
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
JButton beendeProgrammButton;
JButton linksUmButton;
JButton zurWandGehenButton;
JButton vorButton;
//Konstruktor
ButtonsKonstruktor()
{
// neues Frame-Objekt erzeugen
JFrame fenster = new JFrame("Hamster-Steuerung");
/*
Verhalten des Fensters beim Klicken auf X festlegen
JFrame.EXIT_ON_ CLOSE -> Programm wird beendet
JFrame.DO_NOTHING_ON_CLOSE -> nichts tun
JFrame.DISPOSE_ON_CLOSE -> nur das aktuelle Fenster wird geschlossen
*/
// Konstruktor -> this verweist auf den JFrame fenster
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// setLayout(new FlowLayout() -> alle Komponenten nebeneinander anordnen
this.setLayout(new FlowLayout());
// JButtons erzeugen
vorButton = new JButton("vor");
linksUmButton = new JButton("linksUm");
zurWandGehenButton = new JButton("Zur Wand gehen");
beendeProgrammButton = new JButton("Programm beenden");
beendeProgrammButton.setBackground(Color.red);
// ActionListener hinzufügen
linksUmButton.addActionListener(this);
zurWandGehenButton.addActionListener(this);
vorButton.addActionListener(this);
beendeProgrammButton.addActionListener(this);
// Buttons anzeigen
this.add(vorButton);
this.add(linksUmButton);
this.add(zurWandGehenButton);
this.add(beendeProgrammButton);
// Frame platzieren -> 100 Pixel von links/200 Pixel von oben
this.setLocation(100, 200);
/*
Fenstergröße automatisch anpassen
Alternative:
fenster.setSize(Breite, Hoehe);
*/
this.pack();
}
public void actionPerformed(ActionEvent mausKlick)
{
// getSource() -> Quelle ermitteln
// Button vorButton abfragen
if (mausKlick.getSource() == this.vorButton)
{
if (paul.vornFrei()) paul.vor();
}
// Button linksUmButton abfragen
if (mausKlick.getSource() == this.linksUmButton)
{
paul.linksUm();
}
// Button zurWandGehenButton abfragen
if (mausKlick.getSource() == this.zurWandGehenButton)
{
while(paul.vornFrei()) paul.vor();
}
// Button beendeProgrammButton abfragen
if (mausKlick.getSource() == this.beendeProgrammButton)
{
System.exit(0);
}
}
}
void main()
{
// Aufruf des Konstruktors
ButtonsKonstruktor fensterZeigen = new ButtonsKonstruktor();
fensterZeigen.setVisible(true);
}
// Pakete importieren
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JScrollPane;
// globale Variablen
JTextArea tasteGedrueckt;
JScrollPane bildLauf;
class TastaturAbfragen implements KeyListener
{
Hamster paul;
TastaturAbfragen(Hamster neuerHamster)
{
paul = neuerHamster;
}
String infoTasten = "";
public void keyPressed(KeyEvent gedrueckteTaste)
{
int taste = gedrueckteTaste.getKeyCode();
char tasteBuchstabe = gedrueckteTaste.getKeyChar();
if (taste == 37) infoTasten = infoTasten + "Taste: " + taste + " -> Cursor links\n";
else if (taste == 38) infoTasten = infoTasten + "Taste: " + taste + " -> Cursor oben\n";
else if (taste == 39) infoTasten = infoTasten + "Taste: " + taste + " -> Cursor rechts\n";
else if (taste == 40) infoTasten = infoTasten + "Taste: " + taste + " -> Cursor unten\n";
else infoTasten = infoTasten + "Taste: " + taste + " -> " + tasteBuchstabe + "\n" ;
tasteGedrueckt.setText(infoTasten);
// Taste r oder Cursor nach rechts -> rechts
if (taste == 39 || taste == 82)
{
paul.linksUm();
paul.linksUm();
paul.linksUm();
}
// Taste l oder Cursor nach links -> links
if (taste == 37 || taste == 76) paul.linksUm();
// Taste v oder Cursor nach oben -> vor
if (taste == 38 || taste == 86)
{
if (paul.vornFrei())
{
paul.vor();
}
}
// Taste n oder Cursor nach unten -> nimm
if (taste == 40 || taste == 78)
{
if (paul.kornDa())
{
paul.nimm();
}
}
}
// überschriebene Methoden des KeyListener
public void keyReleased(KeyEvent gedrueckteTaste) {}
public void keyTyped(KeyEvent gedrueckteTaste) {}
}
void main()
{
Hamster paul = new Hamster(0, 0, Hamster.OST, 0);
JFrame fenster = new JFrame("Hamster-Steuerung");
tasteGedrueckt = new JTextArea(15, 20);
fenster.add(tasteGedrueckt);
// Bildlauf hinzufügen
JScrollPane bildLauf = new JScrollPane (tasteGedrueckt);
fenster.add(bildLauf);
// KeyListener hinzufügen
tasteGedrueckt.addKeyListener(new TastaturAbfragen(paul));
// Fensterposition
fenster.setLocation(100, 200);
// Fenstergröße festlegen
fenster.setSize(250, 250);
fenster.pack();
fenster.setVisible(true);
tasteGedrueckt.requestFocus();
}
/*
in einem beliebig großem Feld muss der Hamster die Körner einsammeln, die vorher wahllos im Feld verteilt werden.
In der ersten Spalte jeder Zeile werden keine Körner verteilt, sie können als "Zufluchtsort"
für den spielenden Hamster genutzt werden.
Weitere Hamster irren durch das Feld. Trifft der Spielhamster auf einen davon, hat er
verloren. Damit das nichz zu schnell passiert, kann er sich mehrere Leben verschaffen.
Steuerung:
- über die Tastatur:
v oder Cursor oben -> vor
w -> zu nächsten Wand laufen
l oder ursor links -> links,
r oder Cursor rechts -> rechts
n oder Cursor unten -> nimm
s -> Timer stoppen
f -> Timer fortsetzem
e -> Programm beenden
+ -> weiteres Leben
Beim Start können verschiedenene Vorgaben gemacht werden:
- die Anzahl der zu verteilenden Körner
- die Anzahl der Zufallshamster im Feld
- die Zeitvorgabe
- die Anzahl der Leben
(C) Hartmut Waller 2017
*/
// Pakete importieren
import java.awt.FlowLayout;
import javax.swing.JTextArea;
import javax.swing.JFrame;
// ActionListener/KeyListener
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
// Timer
import javax.swing.Timer;
// globale Variablen
int anzahlSchritte;
int anzahlKoerner;
int zeitSekunden;
int gesamtZeit;
int verteilenKoerner;
int anzahlLeben;
boolean timerStartStop = false;
boolean zeitEnde = false;
// Position paul
int paulSpalte;
int paulReihe;
Timer timer;
JTextArea infoTasten;
/*
LaufHamster sind die zufällig sich im Territorium bewegenden Hamster
kreuzen sie auf ihrem Weg den Spielhamster, verliert dieser ein Leben
*/
class LaufHamster extends Hamster
{
LaufHamster(int reihe, int spalte, int blickrichtung, int koerner)
{
this.init(reihe, spalte, blickrichtung, koerner);
}
public void run()
{
while (this.maulLeer())
{
this.geheZuKachel(this.zufallsZahl(0, Territorium.getAnzahlReihen()), this.zufallsZahl(1, Territorium.getAnzahlSpalten()));
// eine Sekunde Pause einlegen
try
{
Thread.sleep(1000);
}
catch(InterruptedException ex)
{
Thread.currentThread().interrupt();
}
/*
beim Verlust des letzten Lebens, der Aufnahme des letzten Korn
oder dem Ende der Zeit
zeitEnde wird auf true gesetzt -> AufLaufHamster stoppen
*/
if (zeitEnde) break;
}
}
void rechtsUm()
{
this.kehrUm();
this.linksUm();
}
void kehrUm()
{
this.linksUm();
this.linksUm();
}
void setzeBlickRichtung(int richtung)
{
while(this.getBlickrichtung() != richtung)
{
this.linksUm();
}
}
void geheZuKachel(int reihe, int spalte)
{
if (reihe > this.getReihe())
{
this.setzeBlickRichtung(Hamster.SUED);
}
else
{
this.setzeBlickRichtung(Hamster.NORD);
}
while (reihe != this.getReihe())
{
if (this.vornFrei()) this.vor();
/*
erste Spalte darf vom spielenden Hamster betreten werden
auch wenn dort ein Hamster steht
*/
if (paulSpalte == this.getSpalte() && paulReihe == this.getReihe() && this.getSpalte() != 0)
{
anzahlLeben --;
if (anzahlLeben == 0)
{
zeitEnde = true;
infoTasten.setText("Du hast leider verloren!");
}
else
{
infoTasten.setText("Du hast noch " + anzahlLeben + " Leben!\nNoch " + anzahlKoerner + " Koerner!");
}
}
}
if (spalte > this.getSpalte())
{
this.setzeBlickRichtung(Hamster.OST);
}
else
{
this.setzeBlickRichtung(Hamster.WEST);
}
while (spalte != this.getSpalte())
{
if (this.vornFrei()) this.vor();
/*
erste Spalte darf vom spielenden Hamster betreten werden
auch wenn dort ein Hamster steht
*/
if (paulSpalte == this.getSpalte() && paulReihe == this.getReihe() && this.getSpalte() != 0)
{
anzahlLeben --;
if (anzahlLeben == 0)
{
zeitEnde = true;
infoTasten.setText("Du hast leider verloren!");
}
else
{
infoTasten.setText("Du hast noch " + anzahlLeben + " Leben!\nNoch " + anzahlKoerner + " Koerner!");
}
}
}
}
// Zufallszahl im Bereich min - max ermitteln
int zufallsZahl(int minZahl, int maxZahl)
{
return (int) (Math.random() * (maxZahl - minZahl) + minZahl);
}
}
class zeitAnzeigen
{
// Konstruktor
zeitAnzeigen()
{
timer = new Timer(1000, new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
// 1 Sekunde abziehen
zeitSekunden--;
// Zeit abgelaufen
if (zeitSekunden == 0)
{
timer.stop();
// Programm beendenwird in TastaturAbfragen angewandt
zeitEnde = true;
infoTasten.setText("Zeit abgelaufen!");
}
}
}
);
timer.start();
}
}
class TastaturAbfragen implements KeyListener
{
LaufHamster paul;
TastaturAbfragen(LaufHamster neuerHamster)
{
paul = neuerHamster;
}
public void keyPressed(KeyEvent gedrueckteTaste)
{
char tasteBuchstabe = gedrueckteTaste.getKeyChar();
int taste = gedrueckteTaste.getKeyCode();
// Taste r oder Cursor nach rechts -> rechts
if (taste == 39 || taste == 82) paul.rechtsUm();
// Taste l oder Cursor nach links -> links
if (taste == 37 || taste == 76) paul.linksUm();
// Taste v oder Cursor nach oben -> vor
if (taste == 38 || taste == 86)
{
if (paul.vornFrei())
{
paul.vor();
// auf der Position befindet sich ein Hamster
if (Territorium.getAnzahlHamster(paul.getReihe(),paul.getSpalte()) > 1 && paul.getSpalte() != 0)
{
anzahlLeben --;
if (anzahlLeben == 0)
{
zeitEnde = true;
infoTasten.setText("Du hast leider verloren!");
}
else
{
infoTasten.setText("Du hast noch " + anzahlLeben + " Leben!\nNoch " + anzahlKoerner + " Koerner!");
}
}
paulSpalte = paul.getSpalte();
paulReihe = paul.getReihe();
anzahlSchritte ++;
}
}
// Taste w -> zur nächsten Wand laufen
if (taste == 87)
{
while (paul.vornFrei()) paul.vor();
}
// Taste n oder Cursor nach unten -> nimm
if (taste == 40 || taste == 78)
{
if (paul.kornDa())
{
paul.nimm();
anzahlKoerner --;
infoTasten.setText("Du hast noch " + anzahlLeben + " Leben!\nNoch " + anzahlKoerner + " Koerner!");
if (anzahlKoerner == 0)
{
zeitEnde = true;
infoTasten.setText("Gewonnen!\nDu hast " + anzahlSchritte + " Schritte\nund " + (gesamtZeit - zeitSekunden) + " Sekunden benoetigt!");
}
}
}
// Taste s -> Timer stoppen
if (taste == 83)
{
timer.stop();
timerStartStop = true;
infoTasten.setText("Verbleibende Zeit: " + zeitSekunden + " Sekunden\nf -> Timer starten");
}
// Taste e -> Ende
if (taste == 69) System.exit(0);
// Taste f -> Timer fortsetzen
if (taste == 70)
{
timer.start();
infoTasten.setText(" v oder Cursor oben -> vor\n w -> zur Wand laufen\n r oder Cursor rechts -> rechts\n l oder Cursor links -> links\n n oder Cursor unten -> nimm\n s -> Timer stoppen\n f -> Timer fortsetzen\n + -> weiteres Leben");
timerStartStop = false;
}
// Taste + weiteres Leben
if (taste == 521)
{
anzahlLeben ++;
infoTasten.setText("Du hast noch " + anzahlLeben + " Leben!\nNoch " + anzahlKoerner + " Koerner!");
}
}
// überschriebene Methoden des KeyListener
public void keyReleased(KeyEvent gedrueckteTaste) {}
public void keyTyped(KeyEvent gedrueckteTaste) {}
}
void main()
{
// neues Frame-Objekt erzeugen
JFrame fenster = new JFrame("Hamster-Spiel");
fenster.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
fenster.setSize(600, 450);
fenster.setLayout(new FlowLayout());
infoTasten = new JTextArea(8, 30);
infoTasten.setEditable(false);
// Textfeld anzeigen
fenster.add(infoTasten);
// Frame platzieren -> 10 Pixel von links/200 Pixel von oben
fenster.setLocation(100, 200);
/*
Fenstergröße automatisch anpassen
Alternative:
fenster.setSize(Breite, Hoehe);
*/
fenster.pack();
// Fenster sichtbar machen
fenster.setVisible(true);
LaufHamster paul = new LaufHamster(0, 0, Hamster.OST, 0);
// Anzahl der zu verteilenden Körner
int koernerMax = ((Territorium.getAnzahlReihen() -1) * (Territorium.getAnzahlSpalten() - 1));
verteilenKoerner = koernerMax;
anzahlKoerner = verteilenKoerner;
// solange fragen bis die Anzahl der zu verteilenden Körner kleiner als koernermax ist
while (verteilenKoerner >= koernerMax || verteilenKoerner == 0) verteilenKoerner = paul.liesZahl("Anzahl der Koerner?\nmaximal " + (koernerMax - 1) + " mindestens 1");
anzahlKoerner = verteilenKoerner;
// Zeitvorgabe
zeitSekunden = paul.liesZahl("Zeit in Sekunden?");
// gesamtZeit sichern -> wird für die Mitteilung am Ende des Programms benötigt
gesamtZeit = zeitSekunden;
// maximale Anzahl der LaufHamster
int anzahlHamsterMax = Territorium.getAnzahlReihen() -1;
int anzahlHamster = anzahlHamsterMax;
// Anzahl der Zufallshamster im Feld
while (anzahlHamster >= anzahlHamsterMax) anzahlHamster = paul.liesZahl("Anzahl der Hamster im Feld? \nMaximal " + (anzahlHamsterMax -1));
anzahlLeben = paul.liesZahl("Wie viele Leben \nsoll der Spielhamster haben?");
// willi läuft nur wenn er Körner im Maul hat -> verteilenKoerner > 0
if (verteilenKoerner > 0)
{
// willi wird initialisiert und verteilt die Körner
LaufHamster willi = new LaufHamster(Territorium.getAnzahlReihen() - 1, Territorium.getAnzahlSpalten() - 1, Hamster.OST, verteilenKoerner);
infoTasten.setText("willi verteilt die Koerner!\nNoch " + verteilenKoerner +" Koerner!");
int koernerRest = verteilenKoerner;
while (!willi.maulLeer())
{
int spalte = willi.zufallsZahl(1, Territorium.getAnzahlSpalten());
int reihe = willi.zufallsZahl(0, Territorium.getAnzahlReihen());
willi.geheZuKachel(reihe, spalte);
if (!willi.kornDa())
{
willi.gib();
koernerRest --;
infoTasten.setText("willi verteilt die Koerner:\nnoch "+ koernerRest + " Koerner!");
}
}
infoTasten.setText("Fertig! willi geht nach unten in die linke Ecke");
// willi geht in die linke untere Ecke
willi.geheZuKachel(Territorium.getAnzahlReihen() - 1, 0);
}
// Info Tastenbelegung
infoTasten.setText(" v oder Cursor oben -> vor\n w -> zur Wand laufen\n r oder Cursor rechts -> rechts\n l oder Cursor links -> links\n n oder Cursor unten -> nimm\n s -> Timer stoppen\n f -> Timer fortsetzen\n + -> weiteres Leben");
// ActionListener/KeyListener hinzufügen
infoTasten.addKeyListener(new TastaturAbfragen(paul));
// Timer aufrufen
new zeitAnzeigen();
/*
Focus auf TextArea infoTasten setzen
nur dann wird ein Tastendruck erkannt
*/
infoTasten.requestFocus();
// Array definieren
LaufHamster[] zufallsHamster = new LaufHamster[anzahlHamster];
// Hamster des Arrays initialsieren und starten
for (int zaehler = 0; zaehler < anzahlHamster; zaehler ++)
{
zufallsHamster[zaehler] = new LaufHamster(Territorium.getAnzahlReihen() - 1, Territorium.getAnzahlSpalten() - 1, Hamster.OST, 0);
zufallsHamster[zaehler].start();
}
}