Wie du willst, hier kommt mal mein ganzes Projekt (die Problemmethode is in der Klasse LABYRINTH)
[code=Java]import java.util.Random;
class SPIELSTEUERUNG
{
//Attribute
int punkteStand;
int anzahlLeben;
int levelNummer;
int punktewertNormalerKruemel;
int punktewertPowerkruemel;
int timer1;
LABYRINTH labyrinth;
MAMPFI mampfi;
STEUERUNGSANZEIGE steuerung;
MONSTER[] monsterliste;
Random zufallszahlGenerator;
SPIELSTEUERUNG()
{
punkteStand = 0;
anzahlLeben = 3;
levelNummer = 1;
LevelVorbereiten();
steuerung = new STEUERUNGSANZEIGE();
steuerung.Anmelden(this);
punktewertNormalerKruemel = 1;
punktewertPowerkruemel = 1;
zufallszahlGenerator = new Random();
monsterliste = new MONSTER[4];
for (int zaehler = 0; zaehler <= 3; zaehler = zaehler+1)
{
monsterliste[zaehler] = new MONSTER(labyrinth, labyrinth.MonsterPositionXGeben(zaehler), labyrinth.MonsterPositionYGeben(zaehler));
}
}
void AufTasteReagieren(int taste)
{
switch(taste)
{
case 37:
mampfi.NachWestenBlicken();
break;
case 38:
mampfi.NachNordenBlicken();
break;
case 39:
mampfi.NachOstenBlicken();
break;
case 40:
mampfi.NachSüdenBlicken();
break;
case 80:
steuerung.TickerAnhalten();
break;
case 83:
if (anzahlLeben > 0)
{
steuerung.TickerStarten(500);
break;
}
case 84:
System.out.println(labyrinth.SindAlleKruemelGefressen());
}
}
void SpielzugAuswerten()
{
if (labyrinth.KruemelbelegungAnzeigen(mampfi.PositionXGeben(), mampfi.PositionYGeben()) == 'P')
{
mampfi.UnverwundbarMachen();
KruemelEntfernen();
punkteStand = punkteStand+punktewertPowerkruemel;
steuerung.PunkteStandSetzen(punkteStand);
for (int zaehler = 0; zaehler <= 3; zaehler = zaehler +1)
{
monsterliste[zaehler].VerwundbarSetzen(true);
monsterliste[zaehler].FuellungSichtbarSetzen(false);
}
timer1 = 30;
}
else
{
if(labyrinth.KruemelbelegungAnzeigen(mampfi.PositionXGeben(), mampfi.PositionYGeben()) == 'N')
{
KruemelEntfernen();
punkteStand = punkteStand+punktewertNormalerKruemel;
steuerung.PunkteStandSetzen(punkteStand);
}
}
for (int zaehler = 0; zaehler <= 3; zaehler = zaehler +1)
if(MonsterMampfiBegegnungTesten(zaehler) == true)
{
if (mampfi.VerwundbarGeben() == false)
{
punkteStand = punkteStand + 200;
monsterliste[zaehler].AufStartpositionSpringen();
}
else
{
if (anzahlLeben > 0)
{
anzahlLeben = anzahlLeben -1;
mampfi.AufStartpositionSpringen();
}
else
{
steuerung.TickerAnhalten();
}
}
}
}
void KruemelEntfernen()
{
labyrinth.KruemelEntfernen(mampfi.PositionXGeben(), mampfi.PositionYGeben());
}
void Tick()
{
switch (mampfi.BlickRichtungGeben())
{
case 'N':
mampfi.NachNordenBewegen();
SpielzugAuswerten();
break;
case 'S':
mampfi.NachSüdenBewegen();
SpielzugAuswerten();
break;
case 'W':
mampfi.NachWestenBewegen();
SpielzugAuswerten();
break;
case 'O':
mampfi.NachOstenBewegen();
SpielzugAuswerten();
}
for (int zaehler = 0; zaehler <= 3; zaehler = zaehler +1)
{
switch(zufallszahlGenerator.nextInt(7))
{
case 0:
monsterliste[zaehler].NachNordenBewegen();
SpielzugAuswerten();
break;
case 1:
monsterliste[zaehler].NachWestenBewegen();
SpielzugAuswerten();
break;
case 2:
monsterliste[zaehler].NachSüdenBewegen();
SpielzugAuswerten();
break;
case 3:
monsterliste[zaehler].NachOstenBewegen();
SpielzugAuswerten();
break;
case 4:
monsterliste[zaehler].InBlickrichtungBewegen();
SpielzugAuswerten();
break;
case 5:
monsterliste[zaehler].InBlickrichtungBewegen();
SpielzugAuswerten();
break;
case 6:
monsterliste[zaehler].InBlickrichtungBewegen();
SpielzugAuswerten();
break;
}
}
if (timer1 > 0)
{
timer1 = timer1 -1;
}
if (timer1 == 0)
{
mampfi.VerwundbarMachen();
for (int zaehler = 0; zaehler <= 3; zaehler = zaehler +1)
{
monsterliste[zaehler].VerwundbarSetzen(false);
monsterliste[zaehler].FuellungSichtbarSetzen(true);
}
}
}
boolean MonsterMampfiBegegnungTesten(int monsterNummer)
{
if (mampfi.PositionXGeben() == monsterliste[monsterNummer].PositionXGeben() && mampfi.PositionYGeben() == monsterliste[monsterNummer].PositionYGeben())
{
return true;
}
return false;
}
void LevelVorbereiten()
{
labyrinth = new LABYRINTH();
mampfi = new MAMPFI(labyrinth, labyrinth.MampfiStartXGeben(), labyrinth.MampfiStartYGeben());
}
}[/code]
[code=Java]//import backend.implementierung.SteuerungsAnzeige;
import backend.Ticker;
import backend.anzeige.Einstellungen;
/**Diese Klasse dient zur Anzeige der Informationen am rechten Rand und
* zur Anmeldung des SPIELSTEUERUNGS-Objekts am backend.
* @author Sebastian Zinkhahn
*/
class STEUERUNGSANZEIGE extends SteuerungsAnzeige
{
/**Der Punktestand*/
int punkteStand;
/**Die Anzahl der Leben*/
int anzahlLeben;
/**Die Nummer des Levels*/
int levelNummer;
/**Die Farbe, in der die Schrift angezeigt wird*/
String schriftFarbe;
/**Die Hintergrundfarbe des Panels*/
String hintergrundFarbe;
/**Erzeugt eine neues Objekt dieser Klasse*/
STEUERUNGSANZEIGE()
{
super();
}
/** Weist dem Attribut punkteStand einen neuen Wert zu
* @param punkteStandNeu Der neue Wert
*/
void PunkteStandSetzen(int punkteStandNeu)
{
super.PunkteStandSetzen(punkteStandNeu);
punkteStand = punkteStandNeu;
}
/** Weist dem Attribut anzahlLeben einen neuen Wert zu
* @param anzahlNeu - Der neue Wert
*/
void LebenSetzen(int anzahlNeu)
{
if(anzahlNeu>=0)
{
super.LebenSetzen(anzahlNeu);
anzahlLeben = anzahlNeu;
}
else System.err.println("Anzahl der Leben darf nicht negativ sein");
}
/** Weist dem Attribut levelNummer einen neuen Wert zu
* @param nummerNeu Der neue Wert
*/
void LevelSetzen(int nummerNeu)
{
if(nummerNeu>=0)
{
super.LevelSetzen(nummerNeu);
levelNummer = nummerNeu;
}
else System.err.println("Nummer des Levels darf nicht negativ sein");
}
/** Weist dem Attribut schriftFarbe einen neuen Wert zu
* @param farbeNeu Der neue Wert (Name der Farbe)
*/
void SchriftFarbeSetzen(String farbeNeu)
{
super.SchriftFarbeSetzen(farbeNeu);
schriftFarbe = farbeNeu;
}
/** Weist dem Attribut hintergrundFarbe einen neuen Wert zu
* @param farbeNeu Der neue Wert (Name der Farbe)
*/
void HintergrundFarbeSetzen(String farbeNeu)
{
super.HintergrundFarbeSetzen(farbeNeu);
hintergrundFarbe = farbeNeu;
}
/** Meldet das übergebene Objekt am Backend als Spielsteurung an
* @param steuerung Das {@link SPIELSTEUERUNG}-Objekt
*/
void Anmelden(SPIELSTEUERUNG steuerung)
{
if(super.steuerungsDummy == null)
{
super.Anmelden(steuerung);
}
else System.err.println("Es wurde schon eine Spielsteuerung angemeldet");
}
/**Setzt in der Klasse {@link Einstellungen} die Anzahl Zellen
* @param anzahl Die Anzahl der Zellen
* @return Der resultierende Zellradius
*/
int ZellenAnzahlSetzen(int anzahl)
{
Einstellungen.ZellenRadiusBerechnen(anzahl);
return Einstellungen.ZellenRadiusGeben();
}
/**Setzt den Zellenradius (halbe Hoehe und Breite einer Zelle)auf den angegebenen Wert
* @param zellenRadiusNeu Der Zellenradius
*/
void ZellenRadiusSetzen(int zellenRadiusNeu)
{
Einstellungen.ZellenRadiusSetzen(zellenRadiusNeu);
}
/**Startet einen {@link Ticker}
* @param zeitIntervall Der Zeitabstand in welchem die Ticks kommen sollen
* in Millisekunden
*/
void TickerStarten(int zeitIntervall)
{
if(super.steuerungsDummy != null)
{
super.TickerStarten(zeitIntervall);
}
else System.err.println("Es muss erst eine Spielsteuerung angemeldet werden");
}
void TickerAnhalten()
{
super.TickerAnhalten();
}
void LabyrinthAnzeigeLoeschen()
{
super.LabyrinthAnzeigeLoeschen();
}
}[/code]
[code=Java]public class LABYRINTH
{
//Attribute
int breite;
int hoehe;
int mampfiStartX;
int mampfiStartY;
int monsterStartX[];
int monsterStartY[];
//Referenzattribute
ZELLE[][] spielFlaeche;
//Konstruktor
LABYRINTH (int breiteNeu, int hoeheNeu)
{
breite = breiteNeu;
hoehe = hoeheNeu;
spielFlaeche = new ZELLE[breite][hoehe];
for (int zaehlerY = 0; zaehlerY<hoehe-1; zaehlerY = zaehlerY+1)
{
for (int zaehlerX = 0; zaehlerX<breite-1; zaehlerX = zaehlerX+1)
{
spielFlaeche[zaehlerX][zaehlerY] = new ZELLE(zaehlerX, zaehlerY);
}
}
mampfiStartX = 0;
mampfiStartY = 0;
spielFlaeche[mampfiStartX][mampfiStartY].KruemelEntfernen();
}
LABYRINTH()
{
breite = 10;
hoehe = 10;
spielFlaeche = new ZELLE[breite][hoehe];
for(int zaehlerX = 0; zaehlerX < 10; zaehlerX = zaehlerX+1)
{
for(int zaehlerY = 0; zaehlerY < 10; zaehlerY = zaehlerY+1)
{
spielFlaeche[zaehlerX][zaehlerY] = new ZELLE(zaehlerX,zaehlerY);
}
}
mampfiStartX = 0;
mampfiStartY = 0;
spielFlaeche[mampfiStartX][mampfiStartY].KruemelEntfernen();
GaengeErstellen(1,2);
GaengeErstellen(7,2);
GaengeErstellen(1,3);
GaengeErstellen(2,3);
GaengeErstellen(6,3);
GaengeErstellen(7,3);
GaengeErstellen(1,4);
GaengeErstellen(3,4);
GaengeErstellen(5,4);
GaengeErstellen(7,4);
GaengeErstellen(1,5);
GaengeErstellen(7,5);
GaengeErstellen(1,6);
GaengeErstellen(4,6);
GaengeErstellen(7,6);
GaengeErstellen(1,7);
GaengeErstellen(7,7);
PowerKruemelVerteilen(2,2);
PowerKruemelVerteilen(6,2);
PowerKruemelVerteilen(4,7);
monsterStartX = new int [4];
monsterStartY = new int [4];
monsterStartX[0] = 9;
monsterStartY[0] = 9;
monsterStartX[1] = 9;
monsterStartY[1] = 8;
monsterStartX[2] = 8;
monsterStartY[2] = 9;
monsterStartX[3] = 8;
monsterStartY[3] = 8;
}
//Methoden
void GaengeErstellen (int positionX, int positionY)
{
spielFlaeche[positionX][positionY].IstMauerSetzen(true);
}
void PowerKruemelVerteilen (int positionX, int positionY)
{
spielFlaeche[positionX][positionY].PowerKruemelVerteilen();
}
int BreiteGeben()
{
return breite;
}
int HoeheGeben()
{
return hoehe;
}
boolean IstMauerAufZelle(int positionX, int positionY)
{
return spielFlaeche[positionX][positionY].IstMauerGeben();
}
int MampfiStartXGeben()
{
return mampfiStartX;
}
int MampfiStartYGeben()
{
return mampfiStartY;
}
char KruemelbelegungAnzeigen(int positionX, int positionY)
{
return spielFlaeche[positionX][positionY].KruemelbelegungAnzeigen();
}
void KruemelEntfernen(int positionX, int positionY)
{
spielFlaeche[positionX][positionY].KruemelEntfernen();
}
int MonsterPositionXGeben(int monsterNummer)
{
return monsterStartX[monsterNummer];
}
int MonsterPositionYGeben(int monsterNummer)
{
return monsterStartY[monsterNummer];
}
boolean IstKruemelAufZelle (int positionX, int positionY)
{
return spielFlaeche[positionX][positionY].IstKruemelGeben();
}
boolean SindAlleKruemelGefressen()
{
for (int zaehlerX = 0; zaehlerX == breite-1; zaehlerX++)
{
for (int zaehlerY = 0; zaehlerY == hoehe-1; zaehlerY++)
{
if (IstKruemelAufZelle(zaehlerX, zaehlerY))
{
System.out.println("Feld[" + zaehlerX + "," + zaehlerY + "] -> Krümel gefunden" );
return false;
}
System.out.println("Feld[" + zaehlerX + "," + zaehlerY + "] -> kein Krümel gefunden" );
}
}
return true;
}
}[/code]
[code=Java]public class ZELLE
{
// Attribute
int positionX;
int positionY;
boolean istMauer;
// Referenzattribute
ZELLENSYMBOL zsymbol;
KRUEMEL kruemel;
// Konstruktor
ZELLE (int xNeu, int yNeu)
{
positionX = 0;
positionY = 0;
istMauer= false;
zsymbol = new ZELLENSYMBOL(xNeu, yNeu);
zsymbol.FuellFarbeSetzen("blau");
zsymbol.RandFarbeSetzen("schwarz");
zsymbol.FuellungSichtbarSetzen(false);
zsymbol.RandSichtbarSetzen(true);
kruemel = new KRUEMEL(xNeu, yNeu);
}
void IstMauerSetzen (boolean istMauerNeu)
{
istMauer = istMauerNeu;
zsymbol.FuellungSichtbarSetzen(istMauerNeu);
if(istMauerNeu == true)
{
if (kruemel != null)
{
kruemel.KruemelSymbolEntfernen();
kruemel = null;
}
}
}
boolean IstMauerGeben()
{
return istMauer;
}
void PowerKruemelVerteilen()
{
kruemel.RadiusSetzen(9);
kruemel.MachtUnverwundbarSetzen(true);
}
void KruemelEntfernen()
{
if (kruemel != null)
{
kruemel.KruemelSymbolEntfernen();
kruemel=null;
}
}
char KruemelbelegungAnzeigen()
{
if (kruemel == null)
{
return 'L';
}
else
{
if( kruemel.MachtUnverwundbarGeben() == true)
{
return 'P';
}
else
{
return 'N';
}
}
}
boolean IstKruemelGeben()
{
if (kruemel == null)
{
return false;
}
else
{
return true;
}
}
}[/code]
Wäre nett wenn jemand zwischenposten könnte, dass ich die restlichen klassen auch noch posten kann.
