array out of bounds

[Endymion]

Bei folgendem Code habe ich ein Problem:

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;
    }
}

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):

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;
            }
        }
    }
}

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

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()
    {
    }
}

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);
    }
}

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;
    }
}

 

[bone2]

monsterliste = new MONSTER[4];
        for (int zaehler = 0; zaehler <= 4; zaehler++)

[c]<= 4[/c] ergibt 5 monster 0, 1, 2, 3, 4, aber in die monsterliste passen nur 4 monster rein. monster[4] hat also keinen platz

 

[VfL_Freak]

Moin,

ohne das jetzt im Detail vollzogen zu haben,klingt es für mich so, als ob an dieser Stelle

public class LABYRINTH
{
    ...
    int MonsterStartYGeben(int MonsterNummer)
    {
        return monsterStartY[MonsterNummer];  // Zeile 120 !!
    }
    ...

kein monsterStartY[4] existiert 😱

Gruß
Klaus

[EDIT]
wieder mal zu langsam ..... :shock:
[/EDIT]

 

[Andi_CH]

Ich bin am schauen, aber mir kommt das nackte GRAUEN!!!


class STEUERUNGSANZEIGE extends SteuerungsAnzeige

Das ist der Horror!

vielleicht schreibt ja in der Zwischenzeit wer anderes warum ... ich hole mal deinen Code rein

 

[Andi_CH]

... und dann fehlen noch massig Klassen - also : Kapitulation.

Bei so vielen Dateien währe es nett neben einzelnen sourcen ein zip-File mit allen Sourcen drin anzuhängen. Ich bin nun mal so, dass ich Fehler lieber mit dem Debugger im Code suche als im geschriebenen Code.

Aber was mindestens "nicht besonders gut" ist
1. Klassennamen in CamelCaseNotation
2. NIE NIE NIE NIEMALS gleiche Namen verwenden, die sich nur durch Gross- und Kleinschreibung unterscheiden - das ist bei der erwähnten Vererbung so, das ist bei der lokalen Variablen labyrinth so -> Natürlich kann der Kompiler damit umgehen und ich weiss auch dass es giwisse Leute bei Parametern und Variablen so machen, aber es ist ein schlechter und sehr schwer zu pflegender Stil!