Syntaxproblem

Endymion

Bekanntes Mitglied
Ich habe in folgender Methode ein Problem:
Java:
 boolean SindAlleKruemelGefressen()
    {
        for (int zaehlerX = 0; zaehlerX == breite-1; zaehlerX = zaehlerX +1)
        {
            for (int zaehlerY = 0; zaehlerY == hoehe-1; zaehlerY = zaehlerY +1)
            {
                if (IstKruemelAufZelle(zaehlerX, zaehlerY) == false || IstMauerAufZelle(zaehlerX, zaehlerY) == true)
                {
                    return true;
                }
            }
        }
        return false;
    }
Die Methode soll für Pacman verwendet werden (das Spiel sollte man ja kennen) um herauszufinden, ob auf der Spielfläche noch Krümel sind. Aber auch wenn alle Krümel aufgefressen sind, bekomme ich false als Ausgabewert. Ich denke, dass es daan liegt, dass
Java:
return false;
an der falschen Stelle ist, aber ich weiß nicht, wo ich es sonst hinschreiben sollte. Weiß jemand, ob es wirklich daran liegt, und wenn ja, wohin ich das schreiben soll?
 

Elendil

Mitglied
Probier doch mal das
Code:
return false;
in deine ganzen for-Schleifen mit einzubauen. Am besten dann mittels else-Anfweisung hinter deine if-Anweisung.
Dann wird auch nicht jedesmal false zurückgegeben
 

Final_Striker

Top Contributor
Ich würde die Methode so implementieren:

Java:
 boolean SindAlleKruemelGefressen()
    {
        for (int zaehlerX = 0; zaehlerX < breite; zaehlerX++)
        {
            for (int zaehlerY = 0; zaehlerY < hoehe; zaehlerY++)
            {
                if (IstKruemelAufZelle(zaehlerX, zaehlerY) == true)
                {
                    return false;
                }
            }
        }
        return true;
    }

Ich laufe über das Feld. Wenn ich ein Krümel gefunden habe, dann kann ich ja gleich [c]false[/c] zurückgeben, da noch Krümel auf dem Spielfeld existieren. Wenn ich das Feld durchsucht und kein Krümel gefunden habe, gebe ich [c]true[/c] zurück.
 
Zuletzt bearbeitet:

Endymion

Bekanntes Mitglied
Bei Elendis Lösung bekomme ich immer die Fehlermeldung "missing return statement".
Bei Final Strikers Lösung bekomme ich immer true, egal ob noch Krümel auf dem Feld sind oder nicht.
 

Elendil

Mitglied
Hmm du bekommst eine Fehlermeldung, da es keine Garantie gibt, dass überhaupt deine for-Schleifen durchlaufen werden. Dann würde es auch keine returnanweisung geben.
Du könntest es mit deshalb mit einer do-while Schleife versuchen. Dann wird der Rumpf mindestens 1x durchlaufen.
 

Final_Striker

Top Contributor
Bau doch einfach ein Paar [c]System.out.println(); [/c] Ausgaben in die Schleife, damit du siehst über welche Felder sie läuft.

Wenn die Schleifen über alle Felder laufen, dann müsste deine IstKruemelAufZelle(zaehlerX, zaehlerY) Methode falsche Angaben zurück liefern.
 

Endymion

Bekanntes Mitglied
Also die Methode IstKruemelAufZelle sieht folgendermaßen aus:
Java:
boolean IstKruemelAufZelle (int positionX, int positionY)
    {
        return spielFlaeche[positionX][positionY].IstKruemelGeben();
    }
Die Methode IstKruemelGeben in der Klasse Zelle sieht folgendermaßen aus:
Java:
boolean IstKruemelGeben()
    {
        if (kruemel == null)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
 

Final_Striker

Top Contributor
z.b so:

Java:
 boolean SindAlleKruemelGefressen()
    {
        for (int zaehlerX = 0; zaehlerX < breite; zaehlerX++)
        {
            for (int zaehlerY = 0; zaehlerY < hoehe; zaehlerY++)
            {
                if (IstKruemelAufZelle(zaehlerX, zaehlerY) == true)
                {
                    System.out.println("Feld[" + zaehlerX + "," + zaehlerY + "] ->  Krümel gefunden" );
                    return false;
                }
                System.out.println("Feld[" + zaehlerX + "," + zaehlerY + "] -> kein Krümel gefunden" );
            }
        }
        return true;
    }
 

Endymion

Bekanntes Mitglied
Ich führe die Methode über eine andere Klasse aus. Wenn ich die Methode anwende, bekomme ich keinen text, sondern nur den Wert true ausgegeben. Liegt das daran, dass ich BlueJ verwende, und sollte ich mein Projekt in Eclipse kopieren, um das zu sehen?
 

Endymion

Bekanntes Mitglied
BlueJ hat bei mir eine Konsole, aber nur wenn ich die Klasse Spielsteuerung aufrufe, ansonsten wird keine erzeugt. kruemel ist keine Variable, sondern ein Objekt der Klasse Kruemel.
 

Endymion

Bekanntes Mitglied
Wie du willst, hier kommt mal mein ganzes Projekt (die Problemmethode is in der Klasse LABYRINTH)

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

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

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

Wäre nett wenn jemand zwischenposten könnte, dass ich die restlichen klassen auch noch posten kann.
 

Endymion

Bekanntes Mitglied
Java:
/**
*
*Diese Klasse dient zur Dastellung einer ZELLE. Dabei ist darauf zu achten, dass
*die ZELLENDARSTELLUNG erst sichtbar wird, wenn ihr x- und y-Position &uuml;bergeben wurden.
*Einmal &uuml;bergeben, lassen sich die Koordinaten nicht mehr &auml;ndern.
*Willst Du z.B. die mit Mausklicks die ZELLE ver&auml;ndern, musst Du sie zuerst an das backend &uuml;bergeben.
*Nutze dazu die Methode Anmelden().
*
*@author Sebastian Zinkhahn
*/

public class ZELLENSYMBOL extends ZellDarstellungImpl
{
  int positionX = super.positionX;
  int positionY = super.positionY;
  String fuellFarbe = "blau";
  String randFarbe = "schwarz";
  boolean fuellungSichtbar = false;
  boolean randSichtbar = true;
  
  /**
   * Erzeugt eine Zelle mit der angebeneben x- und y-Position im Labyrinth
   * @param xNeu
   * @param yNeu
   */
  public ZELLENSYMBOL(int xNeu, int yNeu)
  {
    super(xNeu, yNeu);
    super.FuellFarbeSetzen(fuellFarbe);
    super.FuellungSichtbarSetzen(fuellungSichtbar);
    super.RandFarbeSetzen(randFarbe);
    super.RandSichtbarSetzen(randSichtbar);
  }

//  /**
//   * Setzt die x- und y-Position der Darstellung.
//   * Diese Methode kann nur einmal(!) benutzt werden.
//   * Danach wirken sich die &Auml;nderungen nicht mehr aus.
//   * @see ZellDarstellungImpl#PositionXYSetzen(int, int)
//   */
//  public void PositionXYSetzen(int xNeu, int yNeu)
//  {
//    if(!super.init)
//    {
//      positionX = xNeu;
//      positionY = yNeu;
//    }
//    super.PositionXYSetzen(xNeu, yNeu);
//  }

  
 
  
  /**
   * &Auml;ndert die F&uuml;llfarbe dieses Symbols
   * @see KruemelDarstellungImpl#FarbeSetzen(java.lang.String)
   */
  public void FuellFarbeSetzen(String farbeNeu)
  {
    fuellFarbe = farbeNeu;
    super.FuellFarbeSetzen(farbeNeu);
  }
  
  /**
   * &Auml;ndert die Randfarbe dieses Symbols
   * @see backend.view.DarstellungImpl#RandFarbeSetzen(java.lang.String)
   */
  public void RandFarbeSetzen(String farbeNeu)
  {
    randFarbe = farbeNeu;
    super.RandFarbeSetzen(farbeNeu);
  }
  
  /**
   * Gibt an ob das Symbol ausgef&uuml;llt werden soll
   * @see backend.view.DarstellungImpl#FuellungSichtbarSetzen(boolean)
   */
  public void FuellungSichtbarSetzen(boolean b)
  {
    fuellungSichtbar = b;
    super.FuellungSichtbarSetzen(b);
  }
  
  /**
   * Gibt ob der Rand des Symbols gezeichnet werden soll
   * @see backend.view.DarstellungImpl#RandSichtbarSetzen(boolean)
   */
  public void RandSichtbarSetzen(boolean b)
  {
    randSichtbar = b;
    super.RandSichtbarSetzen(b);
  }
}

Java:
public class KRUEMEL
{
    //Attribute
    int positionX;
    int positionY;
    boolean machtUnverwundbar;    
    //Referenzattribute
    KRUEMELSYMBOL kSymbol;   
    //Konstruktor
    KRUEMEL(int xNeu, int yNeu)
    {
        positionX = xNeu;
        positionY = yNeu;
        machtUnverwundbar = false;
        kSymbol = new KRUEMELSYMBOL(xNeu, yNeu);
    }
    void MachtUnverwundbarSetzen(boolean machtUnverwundbarNeu)
    {
        machtUnverwundbar = machtUnverwundbarNeu;
    }
    boolean MachtUnverwundbarGeben()
    {
        return machtUnverwundbar;
    }
    void KruemelSymbolEntfernen()
    {
        kSymbol.KruemelSymbolEntfernen();
    }
    void RadiusSetzen(int radiusNeu)
    {
        kSymbol.RadiusSetzen(9);
    }
}

Java:
import backend.anzeige.Einstellungen;


/**
 * Die KRUEMELDARSTELLUNG stellt einen Kruemel in Form eines Kreises dar
 * Damit der Kruemel angezeigt wird benoetigt er x- und y-Position und
 * dem backend muss bereits eine ZELLE mit den selben x- und y-Werten bekannt sein.
 * Ansonsten kann es zu Fehlermeldungen kommen.
 * @author Sebastian Zinkhahn
 *
 */
public class KRUEMELSYMBOL extends KruemelDarstellungImpl
{
    int positionX;
    int positionY;
    int radius = 6;
    String fuellFarbe = "Weiss";
    String randFarbe = "Weiss";
    boolean fuellungSichtbar = true;
    boolean randSichtbar = false;
    
    /**
     * Erzeugt eine Kruemel mit den angegebenen x- und y-Werten
     * @param xNeu - die x-Position
     * @param yNeu - die y-Position
     */
    public KRUEMELSYMBOL(int xNeu, int yNeu)
    {
        super(xNeu, yNeu);
        positionX = xNeu;
        positionY = yNeu;
        radius = 6;
        fuellFarbe = "weiss";
        randFarbe = "weiss";
        fuellungSichtbar = true;
        randSichtbar = false;
        super.RandFarbeSetzen(randFarbe);
        super.FuellFarbeSetzen(fuellFarbe);
        super.RandSichtbarSetzen(randSichtbar);
        super.FuellungSichtbarSetzen(fuellungSichtbar); 
    }
    
//  /**
//   * Setzt die x- und y-Position der Darstellung.
//   * Diese Methode kann nur einmal(!) benutzt werden.
//   * Danach wirken sich die Aenderungen nicht mehr aus.
//   * @param xNeu
//   * @param yNeu
//   */
//  void PositionXYSetzen(int xNeu, int yNeu)
//  {
//      if(!super.init)
//      {
//          positionX = xNeu;
//          positionY = yNeu;
//          super.PositionXYSetzen(xNeu, yNeu);
//      }
//      
//  }
    
    /**
     * Aendert den Radius der KRUEMELDARSTELLUNG
     * Benutze diese Methode z.B. dafuer um Kruemel mit unterschiedlichem Wert darzustellen.
     * @see KruemelDarstellungImpl#RadiusSetzen(int)
     */
    public void RadiusSetzen(int radiusNeu)
    {
        if(radiusNeu>= 0 && radiusNeu<=Einstellungen.ZellenRadiusGeben()/2);
        {
            radius = radiusNeu;
            super.RadiusSetzen(radiusNeu);
        }
    }
    
    /**
     * Aendert die Fuellfarbe dieses Symbols
     * @see KruemelDarstellungImpl#FarbeSetzen(java.lang.String)
     */
    public void FuellFarbeSetzen(String farbeNeu)
    {
        fuellFarbe = farbeNeu;
        super.FuellFarbeSetzen(farbeNeu);
    }
    
    /**
     * &Auml;ndert die Randfarbe dieses Symbols
     * @see backend.view.DarstellungImpl#RandFarbeSetzen(java.lang.String)
     */
    public void RandFarbeSetzen(String farbeNeu)
    {
        randFarbe = farbeNeu;
        super.RandFarbeSetzen(farbeNeu);
    }
    
    /**
     * Gibt an ob das Symbol ausgefuellt werden soll
     * @see backend.view.DarstellungImpl#FuellungSichtbarSetzen(boolean)
     */
    public void FuellungSichtbarSetzen(boolean b)
    {
        fuellungSichtbar = b;
        super.FuellungSichtbarSetzen(b);
    }
    
    /**
     * Gibt ob der Rand des Symbols gezeichnet werden soll
     * @see backend.view.DarstellungImpl#RandSichtbarSetzen(boolean)
     */
    public void RandSichtbarSetzen(boolean b)
    {
        randSichtbar = b;
        super.RandSichtbarSetzen(b);
    }
    
    public void KruemelSymbolEntfernen()
    {
        super.KruemelSymbolEntfernen();
    }
    
    
}

Java:
public class SPIELFIGUR
{
    // Attribute
    int positionX;
    int positionY;      
    boolean verwundbar;
    char blickrichtung;
    int startX;
    int startY;
    // Referenzattribute
    LABYRINTH labyrinth;
    //Konstruktor
    SPIELFIGUR (LABYRINTH labyrinthNeu, int StartX, int StartY)
    {
        verwundbar = true;
        blickrichtung = 'N';
        positionX = StartX;
        positionY = StartY;
        labyrinth = labyrinthNeu;
        startX = StartX;
        startY = StartY;
    }
    // Methoden
    void NachOstenBlicken()
    {
        blickrichtung = 'O';
        SymbolAktualisieren();
    }
    void NachNordenBlicken ()
    {
        blickrichtung = 'N';
        SymbolAktualisieren();
    }
    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!");                        
                    }
                }
            }
        }
    }
    void SymbolAktualisieren()
    {
    }
    int PositionXGeben()
    {
        return positionX;
    }
    int PositionYGeben ()
    {
        return positionY;
    }
    boolean VerwundbarGeben()
    {
        return verwundbar;
    }
    void AufStartpositionSpringen()
    {
        positionX = startX;
        positionY = startY;
        SymbolAktualisieren();
    }
}

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

Java:
import backend.anzeige.Einstellungen;

/**
 *Diese Klasse dient zur Darstellung des Mampfi und zum anmelden des MAMPFI-Objekts am backend.
 *@author Sebastian Zinkhahn
 */
class MAMPFISYMBOL extends MampfiDarstellungImpl
{
	/**Die x-Position.*/
	int positionX;
	/**Die y-Position.*/
	int positionY;
	/**Der Radius.*/
	int radius; 
	 /**Gibt den Startwinkel des Bogens von der horizontalen Achse aus gesehen in Grad an.*/
	int startWinkel;
	 /**Gibt den Bogenumfang in Grad an.*/
	int bogenWinkel;
	/**Gibt an wie und ob der Bogen geschlossen ist.<br> Erlaubt sind: 0, 1, 2.*/
	int bogenArt; 
	/**Die Farbe, mit der das Symbol ausgefuellt werden soll.*/
	String fuellFarbe;
	/**Die Farbe, mit der der Rand des Symbols gezeichnet werden soll.*/
	String randFarbe;
	/**Gibt an, ob das Symbol ausgefuellt werden soll.*/
	boolean fuellungSichtbar;
	/**Gibt an, ob der Rand des Symbols gezeichnet werden soll.*/
	boolean randSichtbar;
	/**Gibt an ob sich der Mund sich abwechselnd &ouml;ffnet und schlie&szlig;t */
	boolean mundBewegtSich;

	/** Erzeugt ein neues Objekt dieser Klasse mit Standardwerten.
	 */
	public MAMPFISYMBOL()
	{
		super();
		radius = Einstellungen.ZellenRadiusGeben();
		startWinkel = (int) super.startWinkel;
		bogenWinkel = (int) super.bogenWinkel;
		bogenArt = super.bogenArt;
		fuellFarbe = "gelb";
		randFarbe = "gelb";
		fuellungSichtbar = true;
		randSichtbar = true;
		super.FuellFarbeSetzen(fuellFarbe);
		super.FuellungSichtbarSetzen(fuellungSichtbar);
		super.RandFarbeSetzen(randFarbe);
		super.RandSichtbarSetzen(randSichtbar);
	}
	
	/**Erzeugt ein neues Objekt dieser Klasse mit den &uuml;bergegebenen x- und y-Werten.
	 * @param xNeu die x-Position
	 * @param yNeu die y-Position
	 */
	public MAMPFISYMBOL(int xNeu, int yNeu)
	{
		super(xNeu, yNeu);
		positionX = xNeu;
		positionY = yNeu;
		radius = Einstellungen.ZellenRadiusGeben();
		startWinkel = (int) super.startWinkel;
		bogenWinkel = (int) super.bogenWinkel;
		bogenArt = super.bogenArt;
		fuellFarbe = "gelb";
		fuellFarbe = "gelb";
		randFarbe = "gelb";
		fuellungSichtbar = true;
		randSichtbar = true;
		super.FuellFarbeSetzen(fuellFarbe);
		super.FuellungSichtbarSetzen(fuellungSichtbar);
		super.RandFarbeSetzen(randFarbe);
		super.RandSichtbarSetzen(randSichtbar);
	}
	
	/**Weist dem Attribut radius einen neuen Wert zu.
	 * @param radiusNeu der neue Wert
	 */
	void RadiusSetzen(int radiusNeu)
	{
		if(radiusNeu >= 0 && radiusNeu <= Einstellungen.ZellenRadiusGeben())
		{
			radius = radiusNeu;
			super.RadiusSetzen(radiusNeu);
		}
		else System.err.println("Der Radius darf nicht negativ und nicht gr\u00f6\u00dfer als der Zellradius sein");
	}
	
	/**Weist dem Attribut startWinkel einen neuen Wert zu.
	 * @param winkelNeu der neue Wert
	 */
	void StartWinkelSetzen(int winkelNeu)
	{	
		super.StartWinkelSetzen(winkelNeu);
		startWinkel = winkelNeu;
	}
	
	/**Weist dem Attribut bogenWinkel einen neuen Wert zu.
	 * @param winkelNeu der neue Wert
	 */
	void BogenWinkelSetzen(int winkelNeu)
	{
		super.BogenWinkelSetzen(winkelNeu);
		bogenWinkel = winkelNeu;
	}
	
	/**Weist dem Attribut bogenArt einen neuen Wert zu.
	 * @param bogenArtNeu der neue Wert<br>
	 * 0 - offen,
	 * 1 - Segment,
	 * 2 - Kuchenstueck
	 */
	void BogenArtSetzen(int bogenArtNeu)
	{
		super.BogenArtSetzen(bogenArtNeu);
		bogenArt = bogenArtNeu;
	}
	
	/**Weist dem Attribut positionX einen neuen Wert zu.
	 * @param xNeu der neue Wert
	 */
	void PositionXSetzen(int xNeu)
	{
		super.PositionXSetzen(xNeu);
		positionX = xNeu;
	}
	

	/**Weist dem Attribut positionY einen neuen Wert zu.
	 * @param yNeu der neue Wert
	 */
	void PositionYSetzen(int yNeu)
	{
		super.PositionYSetzen(yNeu);
		positionY = yNeu;
	}
	
	/**Weist dem Attribut fuellFarbe einen neuen Wert zu
	 * @param farbeNeu der neue Wert (Name der Farbe)
	 */
	void FuellFarbeSetzen(String farbeNeu)
	{
		fuellFarbe = farbeNeu;
		super.FuellFarbeSetzen(farbeNeu);
	}
	
	/** Weist dem Attribut randFarbe einen neuen Wert zu
	 * @param farbeNeu der neue Wert (Name der Farbe)
	 */
	void RandFarbeSetzen(String farbeNeu)
	{
		randFarbe = farbeNeu;
		super.RandFarbeSetzen(farbeNeu);
	}
	
	/** Weist dem Attribut fuellungSichtbar einen neuen Wert zu
	 * @param sichtbarNeu true f&uuml;r sichtbar, false f&uuml;r unsichtbar
	 */
	void FuellungSichtbarSetzen(boolean sichtbarNeu)
	{
		fuellungSichtbar = sichtbarNeu;
		super.FuellungSichtbarSetzen(sichtbarNeu);
	}
	
	/**Weist dem Attribut randSichtbar einen neuen Wert zu
	 * @param sichbarNeu true f&uuml;r sichtbar, false f&uuml;r unsichtbar
	 */
	void RandSichtbarSetzen(boolean sichtbarNeu)
	{
		randSichtbar = sichtbarNeu;
		super.RandSichtbarSetzen(sichtbarNeu);
	}
	


	void MundBewegtSichSetzen(boolean bewegtSichNeu)
	{
		super.Bewegen(bewegtSichNeu);
		mundBewegtSich = bewegtSichNeu;
	}
}

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');
    }
    void SymbolAktualisieren()
    {
        if ( verwundbar == false)
        {
            monsterSymbol.FuellFarbeSetzen("rot");
        }
        else
        {
            monsterSymbol.FuellFarbeSetzen("gelb");
        }
        monsterSymbol.PositionXSetzen(positionX);
        monsterSymbol.PositionYSetzen(positionY);
        monsterSymbol.BlickRichtungSetzen(blickrichtung);
    }
    void InBlickrichtungBewegen()
    {
        switch (blickrichtung)
        {
            case 'N':
            NachNordenBewegen();
            break;
            case 'S':
            NachSüdenBewegen();
            break;
            case 'W':
            NachWestenBewegen();
            break;
            case 'O':
            NachOstenBewegen();
            break;
        }
    }
    void FuellungSichtbarSetzen(boolean sichtbarNeu)
    {
        monsterSymbol.FuellungSichtbarSetzen(sichtbarNeu);
    }
}
 

Final_Striker

Top Contributor
[c]
for (int zaehlerX = 0; zaehlerX == breite-1; zaehlerX++)
[/c]

So schreibt man keine for-Schleife, die wird nie ausgeführt.

[c]
for (int zaehlerX = 0; zaehlerX < breite-1; zaehlerX++)
[/c]
 

Ähnliche Java Themen

Neue Themen


Oben