Bei folgendem Code habe ich ein Problem:
Wenn ich auf compile klicke, gibt es keine Fehlermeldung. Wenn ich aber ein Objekt spielsteuerung (code im anhang) erzeuge, bekomme ich für Zeile 120 von labyrinth folgende Fehlermeldung: "java.lang.ArrayOutOfBoundsException: 4". in der grafischen Darstellung wird aber alles korrekt angeziegt. Was hab ich falsch gemacht?
Hier nochmal alle Codes aller relevanten Klassen (Sorry wenns ein bisschen viel ist, aber der Fehler könnte ja überall sein):
Java:
public class LABYRINTH
{
//Attribute
int breite;
int hoehe;
int mampfiStartX;
int mampfiStartY;
int[] monsterStartX;
int[] monsterStartY;
int monsterZahl;
//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();
monsterZahl = 4;
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[monsterZahl];
monsterStartY = new int[monsterZahl];
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 MonsterStartXGeben(int MonsterNummer)
{
return monsterStartX[MonsterNummer];
}
int MonsterStartYGeben(int MonsterNummer)
{
return monsterStartY[MonsterNummer];
}
int MonsterZahlGeben()
{
return monsterZahl;
}
}
Hier nochmal alle Codes aller relevanten Klassen (Sorry wenns ein bisschen viel ist, aber der Fehler könnte ja überall sein):
Java:
import java.util.Random;
class SPIELSTEUERUNG
{
//Attribute
int punkteStand;
int leben;
int level;
int punktewertNormalerKruemel;
int punktewertPowerkruemel;
LABYRINTH labyrinth;
MAMPFI mampfi;
STEUERUNGSANZEIGE steuerung;
MONSTER[] monsterliste;
Random ZufallszahlGenerator;
SPIELSTEUERUNG()
{
punkteStand = 0;
leben = 3;
level = 1;
labyrinth = new LABYRINTH();
mampfi = new MAMPFI(labyrinth, labyrinth.MampfiStartXGeben(), labyrinth.MampfiStartYGeben());
steuerung = new STEUERUNGSANZEIGE();
steuerung.Anmelden(this);
punktewertNormalerKruemel = 1;
punktewertPowerkruemel = 1;
monsterliste = new MONSTER[4];
for (int zaehler = 0; zaehler <= 4; zaehler = zaehler+1)
{
monsterliste[zaehler] = new MONSTER(labyrinth, labyrinth.MonsterStartXGeben(zaehler), labyrinth.MonsterStartYGeben(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 83:
steuerung.TickerStarten(500);
break;
}
}
void SpielzugAuswerten()
{
if (labyrinth.KruemelbelegungAnzeigen(mampfi.PositionXGeben(), mampfi.PositionYGeben()) == 'P')
{
mampfi.UnverwundbarMachen();
KruemelEntfernen();
punkteStand = punkteStand+punktewertPowerkruemel;
steuerung.PunkteStandSetzen(punkteStand);
}
else
{
if(labyrinth.KruemelbelegungAnzeigen(mampfi.PositionXGeben(), mampfi.PositionYGeben()) == 'N')
{
KruemelEntfernen();
punkteStand = punkteStand+punktewertNormalerKruemel;
steuerung.PunkteStandSetzen(punkteStand);
}
}
}
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();
break;
}
for (int zaehler = 0; zaehler == labyrinth.MonsterZahlGeben(); zaehler++)
{
switch(ZufallszahlGenerator.nextInt(7))
{
case 0:
monsterliste[zaehler].NachOstenBewegen();
monsterliste[zaehler].SymbolAktualisieren();
break;
case 1:
monsterliste[zaehler].NachNordenBewegen();
monsterliste[zaehler].SymbolAktualisieren();
break;
case 2:
monsterliste[zaehler].NachWestenBewegen();
monsterliste[zaehler].SymbolAktualisieren();
break;
case 3:
monsterliste[zaehler].NachSüdenBewegen();
monsterliste[zaehler].SymbolAktualisieren();
break;
case 4:
switch (monsterliste[zaehler].BlickRichtungGeben())
{
case 'N':
monsterliste[zaehler].NachNordenBewegen();
break;
case 'S':
monsterliste[zaehler].NachSüdenBewegen();
break;
case 'W':
monsterliste[zaehler].NachWestenBewegen();
break;
case 'O':
monsterliste[zaehler].NachOstenBewegen();
break;
}
monsterliste[zaehler].SymbolAktualisieren();
break;
case 5:
switch (monsterliste[zaehler].BlickRichtungGeben())
{
case 'N':
monsterliste[zaehler].NachNordenBewegen();
break;
case 'S':
monsterliste[zaehler].NachSüdenBewegen();
break;
case 'W':
monsterliste[zaehler].NachWestenBewegen();
break;
case 'O':
monsterliste[zaehler].NachOstenBewegen();
break;
}
monsterliste[zaehler].SymbolAktualisieren();
break;
case 6:
switch (monsterliste[zaehler].BlickRichtungGeben())
{
case 'N':
monsterliste[zaehler].NachNordenBewegen();
break;
case 'S':
monsterliste[zaehler].NachSüdenBewegen();
break;
case 'W':
monsterliste[zaehler].NachWestenBewegen();
break;
case 'O':
monsterliste[zaehler].NachOstenBewegen();
break;
}
monsterliste[zaehler].SymbolAktualisieren();
break;
}
}
}
}
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();
}
}
Java:
public class SPIELFIGUR
{
// Attribute
int positionX;
int positionY;
boolean verwundbar;
char blickrichtung;
// Referenzattribute
LABYRINTH labyrinth;
//Konstruktor
SPIELFIGUR (LABYRINTH labyrinthNeu)
{
verwundbar = true;
blickrichtung = 'N';
positionX = labyrinth.MampfiStartXGeben();
positionY = labyrinth.MampfiStartYGeben();
labyrinth = labyrinthNeu;
}
SPIELFIGUR (LABYRINTH labyrinthNeu, int StartX, int StartY)
{
verwundbar = true;
blickrichtung = 'N';
positionX = StartX;
positionY = StartY;
labyrinth = labyrinthNeu;
}
// Methoden
void NachOstenBlicken()
{
blickrichtung = 'O';
}
void NachNordenBlicken ()
{
blickrichtung = 'N';
}
void NachWestenBlicken ()
{
blickrichtung = 'W';
SymbolAktualisieren();
}
void NachSüdenBlicken ()
{
blickrichtung = 'S';
SymbolAktualisieren();
}
void VerwundbarSetzen(boolean verwundbarNeu)
{
verwundbar = verwundbarNeu;
SymbolAktualisieren();
}
void VerwundbarMachen ()
{
verwundbar = true;
SymbolAktualisieren();
}
void UnverwundbarMachen ()
{
verwundbar = false;
SymbolAktualisieren();
}
void NachOstenBewegen()
{
if(positionX < labyrinth.BreiteGeben()-1)
{
if(labyrinth.IstMauerAufZelle(positionX+1, positionY) == false)
{
positionX = positionX+1;
NachOstenBlicken();
SymbolAktualisieren();
}
}
}
void NachSüdenBewegen ()
{
if(positionY < labyrinth.HoeheGeben()-1)
{
if(labyrinth.IstMauerAufZelle(positionX, positionY+1) == false)
{
positionY = positionY+1;
NachSüdenBlicken();
SymbolAktualisieren();
}
}
}
void NachWestenBewegen ()
{
if(positionX > 0)
{
if(labyrinth.IstMauerAufZelle(positionX-1, positionY) == false)
{
positionX = positionX-1;
NachWestenBlicken();
SymbolAktualisieren();
}
}
}
void NachNordenBewegen ()
{
if(positionY >0)
{
if(labyrinth.IstMauerAufZelle(positionX, positionY-1) == false)
{
positionY = positionY-1;
NachNordenBlicken();
SymbolAktualisieren();
}
}
}
void BlickrichtungSetzen(char blickrichtungNeu)
{
if (blickrichtungNeu == 'S')
{
NachSüdenBlicken();
}
else
{
if (blickrichtungNeu == 'W')
{
NachWestenBlicken();
}
else
{
if (blickrichtungNeu == 'N')
{
NachNordenBlicken();
}
else
{
if (blickrichtungNeu == 'O')
{
NachOstenBlicken();
}
else
{
System.out.println("Falsche Eingabe in der Methode VerwundbarSetzen!");
}
}
}
}
}
int PositionXGeben()
{
return positionX;
}
int PositionYGeben ()
{
return positionY;
}
char BlickRichtungGeben()
{
return blickrichtung;
}
void SymbolAktualisieren()
{
}
}
Java:
class MONSTER extends SPIELFIGUR
{
int geschwindigkeit;
int intelligenz;
MONSTERSYMBOL monsterSymbol;
MONSTER(LABYRINTH labyrinthNeu, int StartX, int StartY)
{
super(labyrinthNeu, StartX, StartY);
verwundbar = false;
intelligenz = 0;
geschwindigkeit = 5;
monsterSymbol = new MONSTERSYMBOL(StartX, StartY);
monsterSymbol.FuellFarbeSetzen("rot");
monsterSymbol.BlickRichtungSetzen('N');
SymbolAktualisieren();
}
void SymbolAktualisieren()
{
if ( verwundbar == false)
{
monsterSymbol.FuellFarbeSetzen("rot");
}
else
{
monsterSymbol.FuellFarbeSetzen("gelb");
}
monsterSymbol.PositionXSetzen(positionX);
monsterSymbol.PositionYSetzen(positionY);
monsterSymbol.BlickRichtungSetzen(blickrichtung);
}
}
Java:
class MAMPFI extends SPIELFIGUR
{
MAMPFISYMBOL symbol;
MAMPFI (LABYRINTH labyrinthNeu, int StartX, int StartY)
{
super(labyrinthNeu, StartX, StartY);
symbol = new MAMPFISYMBOL();
symbol.RadiusSetzen(25);
symbol.StartWinkelSetzen(120);
symbol.BogenWinkelSetzen(300);
symbol.BogenArtSetzen(2);
symbol.FuellFarbeSetzen("gelb");
symbol.PositionXSetzen(StartX);
symbol.PositionYSetzen(StartY);
}
void SymbolAktualisieren()
{
if (verwundbar == true)
{
symbol.FuellFarbeSetzen("gelb");
}
else
{
symbol.FuellFarbeSetzen("rot");
}
symbol.PositionXSetzen(positionX);
symbol.PositionYSetzen(positionY);
switch(blickrichtung)
{
case 'O':
symbol.StartWinkelSetzen(30);
break;
case 'N':
symbol.StartWinkelSetzen(120);
break;
case 'W':
symbol.StartWinkelSetzen(210);
break;
case 'S':
symbol.StartWinkelSetzen(300);
}
}
char BlickRichtungGeben()
{
return blickrichtung;
}
}