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 ArrayListalleZahlen = 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(); } }