Datentypen Color.invisible?

[japa]

Hey, wie kann ich ein Objekt unsichtbar machen?

Objekt.setColor(Color.red);

Wie kann ich jetzt auf unsichtbar machen?

mfg

 

[SlaterB]

Objekt.setUnsichtbar(true);

nur mit Color hilft vielleicht ein hoher bzw. niedriger Alpha-Wert

An alpha value of 1.0 or 255 means that the color is completely opaque and an alpha value of 0 or 0.0 means that the color is completely transparent.

Color (Java 2 Platform SE v1.4.2)

 

[Der Müde Joe]

>Hey, wie kann ich ein Objekt unsichtbar machen?

Es nicht zeichnen lassen. Oder meinst du sowas wie Transparenz (goolge java transparecny)

@SlaterB :applaus: YMMD

EDIT:
zb
Java2D: An Introduction and Tutorial

 

[japa]

ICh will so machen, dass man es nicht mehr sehen kann, entweder unsichtbar oder halt transparenz.

Kann ich irgendwie nicht mit Color machen? weil ich meine Objekte mit Color definiert hab.

mfg

 

[Tomate_Salat]

.setVisible(false);

oder :

Color transparent = new Color(0,0,0,100);
myJComponent.setOpaque(true);
myJComponent.setBackground( transparent );

MFG

Tomate_Salat

 

[cr33p]

Naja, Color einfach zur Hintergrund-Farbe ändern.

Wenn der Hintergrund rot ist, machst einfach das Objekt rot oder wenn du alle Objekte in einer Collection hast einfach das jeweilige Objekt löschen bzw. in eine andere Collection einfügen.

z.B.

Vector<DeinObjekt> sichtbar = new Vector<DeinObjekt>();
Vector<DeinObjekt> unsichtbar = ...

Wenn du's dann unsichtbar haben willst:

unsichtbar.add(sichtbar.get(index));
sichtbar.remove(index);

Und wenn du's später wieder sichtbar haben willst einfach:

sichtbar.add(unsichtbar.get(index));
unsichtbar.remove(index);

Funktioniert natürlich nur wenn du die Objekte mit einer Schleife (for each) ausliest und zeichnest.

 

[Tomate_Salat]

das klingt für mich nach: Ein Panel mit n-Komponenten die nach Events sichtbar und unsichtbar gemacht werden, obwohl man das ganze mittels CardLayout oder JTabedpane einfacher, eleganter und bestimmt auch optisch schöner hinbekommt.

Swing und transparente Objekte ist so eine Sache, bei manchen funktioniert es sofort, andere benötigen diverse extras wie: Ränder transparent zeichnen etc. Wollte mir mal eine schöne Fade-In-Animation schreiben...ich habs dann iwann aufgegeben, weil ich mir dachte: Ieinen Sonderfall wirst du vergessen und ab dann sieht es nurnoch nach MIST aus.

 

[japa]

public class Ball {
	private Color cellColor;
	boolean selected;

Ich nicht alles verstanden was ihr gemeint habt, was ich habe alles probiert was ich verstanden konnte, ich komme aber nicht weiter.

cellColor.setVisible(false);

das funktioniert nicht

 

[Tomate_Salat]

[c]setVisible[/c] ist eine Methode von [c]JComponent[/c] :-/

 

[japa]

ARG, dieses Spiel sollen wir nachprogrammieren. Wir hatten seinen Gerüst bekommen.

Ich schaffe bis so weit, dass die Felde markiert sind, beim zweiten mal klicken soll die selectierte Felde "unsichtbar / transpanrenz / gelöscht " werden.

Ich hatte sogar gemacht

feld[x][y] = new Objekt();

probiert, es kommt aber

java.lang.NullPointerException

raus, weil die Farben halt NULL ist.

mfg

versteh jemand was ich meine?

 

[Michael...]

Ich nicht. Quellcode wäre interessanter als die kompilierten Klassen ;-)

 

[Tomate_Salat]

:bahnhof::noe: und ARG kenne ich auch nicht :noe:

 

[japa]

OK, ich wollte euch mit meinem Problem nicht belasten, aber wenn ihr leseen wollt ^^

Statistics

/*
 * Created on 10.08.2005
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Generation - Code and Comments
 */
package de.hska.faki.logic;

/**
 * 
 * @author holger
 *
 * Statistiken aller Spiele.
 */
public class Statistics {
    private int gamesPlayed            = 0;
    private int maxPoints              = 0;
    private int prevGamePoints         = 0;
    private int currentSelectionPoints = 0;
    private int currentGamePoints      = 0;
    private int allPoints              = 0;

    /**
     * Löscht die komplette Statistik.
     */
    public void clear() {
        gamesPlayed            = 0;
        maxPoints              = 0;
        prevGamePoints         = 0;
        currentSelectionPoints = 0;
        currentGamePoints      = 0;
        allPoints              = 0;
    }
    
    /**
     * Liest die Anzahl gespielter Runden.
     * @return Die Anzahl gespielter Runden.
     */
    public int getGamesPlayed() {
        return gamesPlayed;
    }

    /**
     * Liest den höchsten Spielstand aller Spiele.
     * @return Der höchste Spielstand.
     */
    public int getHighscore() {
        return maxPoints;
    }
    
    /**
     * Liest den Spielstand des letzten Spiels.
     * @return Spielstand des letzten Spiels.
     */
    public int getScoreLastGame() {
        return prevGamePoints;
    }
    
    /**
     * Beendet ein Spiel. Der Spielstand des laufenden Spiels
     * wird als Ergebnis übernommen. 
     * Dabei wird der Highscore neu gesetzt, falls in der letzten
     * Runde mehr Punkte als beim bisherigen Höchststand erreicht
     * wurden. Weiterhin wird die Anzahl der gespielten Spiele erhöht.
     */
    public void finishGame() {
        this.prevGamePoints = currentGamePoints;
        allPoints += currentGamePoints;
        if (prevGamePoints > maxPoints) {
            maxPoints = prevGamePoints;
        }
        gamesPlayed++;
        currentGamePoints = 0;
    }
    
    /**
     * Liest die Punkte der aktuell selektierten Zellen.
     * @return Punkte der aktuell selektierten Zellen.
     */
    public int getCurrentSelectionPoints() {
        return currentSelectionPoints;
    }
    
    /**
     * Schreibt die Punkte der aktuell selektierten Zellen.
     * @param currentSelectionPoints Punkte für die aktuelle Selektion.
     */
    public void setCurrentSelectionPoints(int currentSelectionPoints) {
        this.currentSelectionPoints = currentSelectionPoints;
    }

    /**
     * Ermittelt die Anzahl Punkte im jetzt laufenden Spiel.
     * @return Anzahl Punkte im laufenden Spiel.
     */
    public int getCurrentGamePoints() {
        return currentGamePoints;
    }

    /**
     * Addiert einen Wert zur Anzahl Punkte im laufenden Spiel.
     * @param addGamePoints Anzahl zu addierender Punkte.
     */
    public void addToCurrentGamePoints(int addGamePoints) {
        this.currentGamePoints += addGamePoints;
    }
    
    /**
     * Ermittelt den Mittelwert aller Punkte.
     * @return Mittelwert.
     */
    public int getAverage() {
        return gamesPlayed > 0 ? allPoints / gamesPlayed : 0;
    }
}

Jawbreaker

package de.hska.faki.visual;

import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;

import de.hska.faki.logic.JawbreakerGame;

/**
 * Erzeugen des Spiels in einem Fenster.
 * 
 * @author Holger Vogelsang
 */
public class Jawbreaker extends JFrame {

    /** 
     * Feldbreite in Zellen.
     */
    private static final int WIDTH = 11;

    /** 
     * Feldhöhe in Zellen.
     */
    private static final int HEIGHT = 12;

    /**
     * Referenz auf die Spiellogik.
     */
    private JawbreakerGame breakerGame;

    /**
     * Referenz auf das Panel, das die Ausgaben vornimmt.
     */
    private JawbreakerPanel breakerPanel;

    /**
     * Erzeugt das komplette Spiel.
     */
    public Jawbreaker() {
        super("Jawbreaker");
        breakerGame  = new JawbreakerGame(WIDTH, HEIGHT);
        breakerPanel = new JawbreakerPanel(breakerGame);
        
        getContentPane().setLayout(new BorderLayout());
        getContentPane().add(breakerPanel);
        
        JLabel points = new JLabel("0");
        breakerPanel.setScoreLabel(points);
        points.setHorizontalAlignment(SwingConstants.RIGHT);
        getContentPane().add(points, BorderLayout.SOUTH);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    
    
    /**
     * Die Methode wird beim Start des Programms aufgerufen.
     * @param args Kommandozeilenparameter
     */
    public static void main(String[] args) {

        Jawbreaker breaker = new Jawbreaker();
        breaker.pack();
        breaker.setVisible(true);

    }
}

JawbreakerPanel

package de.hska.faki.visual;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.HashMap;

import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

import de.hska.faki.logic.JawbreakerGame;

/**
 * Visualisierung des Jawbreaker-Spiels.
 * 
 * @author Holger Vogelsang
 */
public class JawbreakerPanel extends JPanel implements MouseListener {

    /**
     * Referenz auf das Spiel des Benutzers.
     */
    private JawbreakerGame breakerGame;
    private JLabel         scoreLabel;
    private Point          clickedCell = null;
    private Font           font = null;
    
    /**
     * Cache fuer die Farben und deren Abstufungen, um nicht permanent neue Farbobjekte
     * mit brighter() und darker() zu erzeugen.
     */
    private HashMap<Color, Color> selectedColors     = new HashMap<Color, Color>();
    private HashMap<Color, Color> darkerColors       = new HashMap<Color, Color>(); 
    private HashMap<Color, Color> brighterColors     = new HashMap<Color, Color>(); 

    /**
     * Erzeugt ein neues Panel.
     * Die Größe des Panels berechnet sich aus der Anzahl
     * der Zellen im Spiel sowie der Größe der einzelnen Zellen.
     *
     * @param nBreakerGame Referenz auf das Spiel, das angezeigt werden soll.
     */
      public JawbreakerPanel(JawbreakerGame nBreakerGame) {
        breakerGame = nBreakerGame;
        addMouseListener(this);
        setPreferredSize(new Dimension(600, 605));
      }

      /**
       * Neuzeichnen des Panel.
       * Die Zeichenmethode wird intern vom Browser aufgerufen,
       * wenn ein Neuzeichnen notwendig ist.
       *
       * @param gr Referenz auf den Grafikkontext.
       */
      public void paintComponent(Graphics gr) {
        Graphics2D graphics  = (Graphics2D) gr;
        boolean    selection = false;
        
        int cellSize = getCellSize();

        // Hintergrund löschen
        graphics.setColor(Color.white);
        graphics.fillRect(0, 0, getSize().width, getSize().height);

        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
                                  RenderingHints.VALUE_ANTIALIAS_ON);
        
        for (int x = 0; x < breakerGame.getWidth(); x++) {
          for (int y = 0; y < breakerGame.getHeight(); y++) {
            Color col = breakerGame.getCellColor(x, y);
            if (col != null) {
                if (breakerGame.isCellSelected(x, y)) {
                    Color selectedCellColor = selectedColors.get(col);
                    if (selectedCellColor == null) {
                        selectedCellColor = col.darker().darker().darker();
                        selectedColors.put(col, selectedCellColor);
                    }
                    col = selectedCellColor;
                    selection = true;
                }
                // Dunklere Farbe erzeugen bzw. lesen
                Color darkerColor = darkerColors.get(col);
                if (darkerColor == null) {
                    darkerColor = col.darker();
                    darkerColors.put(col, darkerColor);
                }
                // Hellere Farbe erzeugen bzw. lesen
                Color brighterColor = brighterColors.get(col);
                if (brighterColor == null) {
                    brighterColor = col.brighter();
                    brighterColors.put(col, brighterColor);
                }
                graphics.setPaint(new GradientPaint(2 + x * cellSize, 2 + y * cellSize, darkerColor, 
                                                    2 + x * cellSize + cellSize - 2,
                                                    2 + y * cellSize + cellSize - 2, brighterColor));
                graphics.fillOval(2 + x * cellSize,
                                  2 + y * cellSize,
                                  cellSize - 2, cellSize - 2);
                
                graphics.setColor(darkerColor);
                graphics.drawOval(2 + x * cellSize,
                        2 + y * cellSize,
                        cellSize - 2, cellSize - 2);
            }
          }
        }
        
        // Mindestens eine Zelle ist selektiert: Punkte anzeigen
        if (selection) {
            String selectedCellPoints = String.valueOf(breakerGame.getStatistics().getCurrentSelectionPoints());
            graphics.setColor(Color.white);
            if (font == null || font.getSize() != cellSize / 3) {
                font = new Font(Font.SANS_SERIF, Font.BOLD, cellSize / 3);
            }
            graphics.setFont(font);
            FontMetrics fm = graphics.getFontMetrics();
            graphics.drawString(selectedCellPoints, 
                                (int) (clickedCell.x * cellSize + (cellSize - fm.stringWidth(selectedCellPoints)) / 2), 
                                (int) (clickedCell.y * cellSize + (cellSize - fm.getHeight())));
            selection = false;
        }
      }

    /**
     * Ermittelt die Ausmaße einer Zelle. 
     * @return Die Ausmaße einer Zelle.
     */
    private int getCellSize() {
        int cellSize = Math.min(getSize().width  / breakerGame.getWidth(),
                                getSize().height / breakerGame.getHeight());
        return cellSize;
    }

    /**
     * Mausklick: Bildschirmposition in Feldposition umrechnen.
     * @param event Systemereignis
     */
    public void mouseClicked(MouseEvent event) {
        int cellSize = getCellSize();
        int xField = event.getX() / cellSize;
        int yField = event.getY() / cellSize;

        // Click außerhalb?
        if ((xField >= breakerGame.getWidth()) || (yField >= breakerGame.getHeight())) {
            return;
        }

        if (clickedCell == null) {
            clickedCell = new Point(xField, yField);
        }
        else {
            clickedCell.x = xField;
            clickedCell.y = yField;
        }
        
        breakerGame.click(xField, yField);
        
        // Aktuelle Punktezahl anzeigen
        scoreLabel.setText(String.valueOf(breakerGame.getStatistics().getCurrentGamePoints()));
        
        repaint();

        if (breakerGame.isGameOver()) {
            scoreLabel.setText(String.valueOf(breakerGame.getStatistics().getScoreLastGame()));
            JOptionPane.showMessageDialog(null, "Game over!");
            removeMouseListener(this);
        }
    }

    public void mousePressed(MouseEvent e) {
    }

    public void mouseReleased(MouseEvent e) {
    }

    public void mouseEntered(MouseEvent e) {
    }

    public void mouseExited(MouseEvent e) {
    }

    public void setScoreLabel(JLabel points) {
        scoreLabel = points;
    }
}

JawbreakerGame diese KLasse muss ich schreiben

package de.hska.faki.logic;

import java.awt.Color;
// 

import de.hska.faki.visual.Jawbreaker;

// Diese Klasse wurde von mir erstellt
public class JawbreakerGame {
	Statistics statistics = new Statistics();

	
	private int width;
	private int height;

	private int x = -1;			// Aktuelle selectiertes FElD
	private int y = -1;			
	private Ball [][] field;	
	private int fieldNummer; 
	public void JawBreakerGame() {
		
	}
	/**.
	 * Ein Feld für das Spiel wird erstellt und Farben hinzuigefügt
	 * @param width
	 * @param height
	 */
	public JawbreakerGame(int width, int height) {
		field = new  Ball [width][height];
		
		for (int column = 0; column < width; column++ ){
			for (int row = 0; row < height; row++) {
				field[column][row] = new Ball(); // keine ahnung
				switch ((int)(Math.random()*4)){
					case 0: field[column][row].setCellColor(Color.red); 	
						break;
					case 1: field[column][row].setCellColor(Color.blue); 
						break;
					case 2: field[column][row].setCellColor(Color.green);
					 	break;
					case 3: field[column][row].setCellColor(Color.yellow);
						break;
					default:
				}


				
			}
		}
		// Feld erstellen
		this.width = width; 
		this.height = height;
	}
	/**.
	 * 
	 * @return
	 */
	public int getxField() {
		return x;
	}
	/**.
	 * 
	 * @param x
	 */
	public void setxField(int xField) {
		this.x = xField;
	}
	/**.
	 * written
	 * @return
	 */
	public int getyField() {
		return y;
	}
	/**.
	 * 
	 * @param y
	 */
	public void setyField(int yField) {
		this.y = yField;
	}
	/**.
	 * 
	 * @return
	 */
	public int getWidth() {
		return this.width;
	}
	/**.
	 * 
	 * @param width
	 */
	public void setWidth(int width) {
		this.width = width;
	}
	/**.
	 * 
	 * @return
	 */
	public int getHeight() {
		return this.height;
	}
	/**.
	 * 
	 * @param height
	 */
	public void setHeight(int height) {
		this.height = height;
	}
	/**.
	 * Write SCHWER
	 * @param x
	 * @param y
	 * @return
	 */
	public Color getCellColor(int x, int y) {
		if(x >= 0 && x<= width && y >= 0 && y <= height) {
			return field[x][y].getCellColor();
		}
		return null;
	}
	/**.
	 * Write SCHWER
	 * @param x
	 * @param y
	 * @return
	 */
	public boolean isCellSelected(int x, int y) {
		// TODO Auto-generated method stub
		return false;
	}
	/**.
	 * Write
	 * @return
	 */
	public Statistics getStatistics() { // Doppeltverschachtung beim jawbreakerpanel
		return statistics;
	}

	/**
	 * written
	 * @param x
	 * @param y
	 */
	public void click(int x, int y) { 
		// Auf weises Feld geklickt und die aufhebung wird aufgehoben
		if (field[x][y].getCellColor() == Color.WHITE){
			fieldNummer = 0;
			deselectNeighbors(this.x,this.y);
			this.x = -1;
			this.x = -1;
		} else if (field[x][y].isSelected()) {
			if(existNeighbors(x, y)) { // einzelnes Feld kann nicht verarbeitet werden
				deleteSelected();
			}
		} else { // wenn auf andere Feld geprüft wird
			
			if(this.x >= 0 && this.y >= 0) {
				fieldNummer = 0;
				deselectNeighbors(this.x,this.y); // markierung der nachbaren wird aufgehoben
			} // Defaultwert wird überprüft
			
			selectNeighbors(x,y); // nachbaren werden markiert
			
			this.x = x;
			this.y = y;
			
		}
		// Write
	}
	/**
	 * Die Nachbaren werden gesucht und selectiert
	 * @param x
	 * @param y
	 */
	public void selectNeighbors (int x, int y) {
		System.out.println(++fieldNummer);
		Color color = field[x][y].getCellColor();
		field[x][y].setSelected(true);
		
		if((x+1) < width && y < height && (x+1) >= 0 && y >= 0 &&
				field[x+1][y].getCellColor().equals(color)) { 
			selectNeighbors(x+1, y);
		}
		if((x-1) < width && y < height && (x-1) >= 0 && y >= 0 &&
				field[x-1][y].getCellColor().equals(color)) {
			selectNeighbors(x-1, y);
		}
		if(x < width && (y+1) < height && x >= 0 && (y+1) >= 0 &&
					field[x][y+1].getCellColor().equals(color)) {
			selectNeighbors(x, y+1);
		}
		if(x < width && (y-1) < height && x >= 0 && (y-1) >= 0 && 
					field[x][y-1].getCellColor().equals(color)) {
			selectNeighbors(x, y-1);
		}
		// farbe weiß setzen und verschieben
		// spalten verschieben evt.
	}
	/**
	 * Die Nachbaren werden gesucht und deselectiert
	 * @param x
	 * @param y
	 */
	public void deselectNeighbors (int x, int y) {
		Color color = field[x][y].getCellColor();
		field[x][y].setSelected(false);
		if((x+1) < width && y < height && (x+1) >= 0 && y >= 0 &&
				field[x+1][y].getCellColor().equals(color)) { 
			deselectNeighbors(x+1, y);
		}
		if((x-1) < width && y < height && (x-1) >= 0 && y >= 0 &&
				field[x-1][y].getCellColor().equals(color)) {
			deselectNeighbors(x-1, y);
		}
		if(x < width && (y+1) < height && x >= 0 && (y+1) >= 0 &&
					field[x][y+1].getCellColor().equals(color)) {
			deselectNeighbors(x, y+1);
		}
		if(x < width && (y-1) < height && x >= 0 && (y-1) >= 0 && 
					field[x][y-1].getCellColor().equals(color)) {
			deselectNeighbors(x, y-1);
		}
	
	}
	/**.
	 * Selectierte Felde werden gelöscht
	 */
	public void deleteSelected() {
		for (int column = 0; column < width; column++ ){
			for (int row = 0; row < height; row++) {
				if(field[column][row].isSelected()) { // SCHWER unsicht transparenz oder löschen
					field[column][row]  = new Ball();
//					field[column][row].setCellColor(Color.black);
				}
			}
		}
	}
	/**.
	 * Nachbaren werden gesucht
	 * @param x
	 * @param y
	 * @return true wenn mindesten 1 Nachbar gefunden wurde, false - wenn kein Nachbar gefunden wurde
	 */
	public boolean existNeighbors (int x, int y) {
		Color color = field[x][y].getCellColor();
		if((x+1) < width && y < height && (x+1) >= 0 && y >= 0 &&
				field[x+1][y].getCellColor().equals(color)) { 
			return true;
		} else if((x-1) < width && y < height && (x-1) >= 0 && y >= 0 &&
				field[x-1][y].getCellColor().equals(color)) {
			return true;
		} else if(x < width && (y+1) < height && x >= 0 && (y+1) >= 0 &&
					field[x][y+1].getCellColor().equals(color)) {
			return true;
		} else if(x < width && (y-1) < height && x >= 0 && (y-1) >= 0 && 
					field[x][y-1].getCellColor().equals(color)) {
			return true;
		}
		return false;
	}
	
	/**.
	 * Write SCHWER
	 * @return
	 */
	public boolean isGameOver() {
		
		
		
		// Jedes Feld wird überprüft und dann wird gestest ob true oder false rausgegeben wird
		// for schleife schreiben, wenn eine Möglichkeit gefunden wurde, dann wird true return gemacht
		
		return false;
	}


}

Ball diese Klasse muss ich auch schreiben

package de.hska.faki.logic;

import java.awt.Color;

public class Ball {
	private Color cellColor;
	boolean selected;
	// Minus nicht verfügbar ,0 noch nicht geprüft, Plus verfügbar
	private int neighbors; 
	

	public Ball() {
		selected = false;

	}
	
	public boolean isSelected() {
		return selected;
	}
	// white setzen

	public void setSelected(boolean selected) {

		if(selected) {
			cellColor = cellColor.darker();
			cellColor = cellColor.darker();
		} else {
			cellColor = cellColor.brighter();
			cellColor = cellColor.brighter();
			
			
		}
		this.selected = selected;
	}


	
	public Color getCellColor() {
		return cellColor;
	}

	public void setCellColor(Color cellColor) {
		this.cellColor = cellColor;
	} 	
	

}

 

[Michael...]

Worum's geht habe ich immer noch nicht verstanden. Was passiert mit den Objekten vom Typ Ball sollen die mal irgendwo gezeichnet werden?

wenn aus irgendeinem Grund mehrfach setSelected(true) hintereinander aufgerufen wird, wird die Farbe immer dunkler, ist das Absicht?

    public void setSelected(boolean selected) {
 
        if(selected) {
            cellColor = cellColor.darker();
            cellColor = cellColor.darker();
        } else {
            cellColor = cellColor.brighter();
            cellColor = cellColor.brighter();
        }
        this.selected = selected;
    }

 

[japa]

Worum's geht habe ich immer noch nicht verstanden. Was passiert mit den Objekten vom Typ Ball sollen die mal irgendwo gezeichnet werden?

wenn aus irgendeinem Grund mehrfach setSelected(true) hintereinander aufgerufen wird, wird die Farbe immer dunkler, ist das Absicht?

    public void setSelected(boolean selected) {
 
        if(selected) {
            cellColor = cellColor.darker();
            cellColor = cellColor.darker();
        } else {
            cellColor = cellColor.brighter();
            cellColor = cellColor.brighter();
        }
        this.selected = selected;
    }

Ja das ist Absicht, damit man auch weiß, welche Farben gerade selectiert wurde.
Wenn man andere Farbe gewählt hat, dann wird die Farbe wieder normal.
Schau mal das Spiel an, dann verstehst du vielleicht besser. Ich muss jetzt hinkriegen, dass man die Objekt nicht mehr sehen kann, wenn man zweimal draufklicken.

mfg

 

[Tomate_Salat]

So richtig verstehe ich das auch nicht. Vor allem, wenn der Ball jemals gezeichnet werden sollte bisher, dann doch richtig umständlich . Wieso erbt Ball nicht von JComponent? Dann hast du [c]setVisible[/c] und kannst das Ding auch Zeichnen und sogar (mit Transparentz) bemalen.

Oder erstellst du ein Panel und weist dem dann die Eigenschaften von Ball zu? Ich will mal hoffen das nicht

Edit Ist dein Anhang die Musterlösung oder das was du bisher gemacht hast? Da die Bälle gezeichnet werden und die die Bälle auch verschwinden, schätze ich mal: Musterlösung

 

[japa]

"Wieso erbt Ball nicht von JComponent?" <-- wie kann ich das machen?

public class Ball ....... ?{

Die andere Klassen darf ich nicht ändern, sondern nur Ball und jawbreakergame

Anhang ist die fertige Lösung, ich soll so weit erweitern, sodass mein programm am Ende genau so AUSSEHEN.

 

[Tomate_Salat]

Ähm ok. Vererbung geht so:

public class Ball extends JComponent {

Ist das eine Hausaufgabe oder soetwas (keine Angst, wir helfen auch bei Hausaufgaben ;-) )? Falls ja: hat das euer Lehrer euch nicht beigebracht?

 

[japa]

*hust*
Studium, das ist eine von 6 Labor Aufgaben ^^

field[column][row].setVisible(false);

geht leider auch nicht -.-, komisch

 

[Michael...]

Ja das ist Absicht, damit man auch weiß, welche Farben gerade selectiert wurde.
Wenn man andere Farbe gewählt hat, dann wird die Farbe wieder normal.

Deswegen meinte ich ja, falls aus irgendwelchen Gründen die Methode mehrfach mit z.B. true aufgerufen wird...
Besser fände ich es beim Setzen der Farbe eine zweite Farbe für die Selektion zu berechnen und diese in einer zweiten Variablen zu speichern. Dann muss man nicht dauernd die Farben neu berechnen.

Schau mal das Spiel an, dann verstehst du vielleicht besser.

Ist das mit JDK 1.6 erstellt? Hab ich leider nicht auf meinem Rechner.

 

[Tomate_Salat]

:-/ Ich habe mir das mal ein bisschen genauer angeschaut. Vergiss das mit JComponent, für den ist Ball ein "Model" der nimmt nur die Werte daraus und Zeichnet dann in der paintComponent von [c]JawbreakerPanel[/c] die Bälle. Naja, jetzt weiste immerhin, wie eine Klasse von einer anderen Erbt.

Ok auf den schnellen Blick:
das verdunkeln und aufhellen der Farben übernimmt die Klasse [c]JawbreakerPanel[/c] selbst. Ich glaube alles was du tun musst, damit der Ball nicht gezeichnet wird, ist als Farbe den Wert [c]null[/c] zurückzugeben

MFG

Tomate_Salat

 

[japa]

Java 1.6

Das ist im Moment nicht mein Problem, sondern dass man es immer noch sieht.

Eine komische sache noch, wenn die, die unsichtbar in Color.black machen würde, dann funkioniert es, aber bei Color.white ergibt sich fehler

null, meinst du so?

field[column][row] = null;

Die Idee hatte ich auch, aber dann

Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
	at de.hska.faki.logic.JawbreakerGame.getCellColor(JawbreakerGame.java:118)
	at de.hska.faki.visual.JawbreakerPanel.paintComponent(JawbreakerPanel.java:80)
	at javax.swing.JComponent.paint(Unknown Source)
	at javax.swing.JComponent.paintToOffscreen(Unknown Source)
	at javax.swing.RepaintManager$PaintManager.paintDoubleBuffered(Unknown Source)
	at javax.swing.RepaintManager$PaintManager.paint(Unknown Source)
	at javax.swing.RepaintManager.paint(Unknown Source)
	at javax.swing.JComponent._paintImmediately(Unknown Source)
	at javax.swing.JComponent.paintImmediately(Unknown Source)
	at javax.swing.RepaintManager.paintDirtyRegions(Unknown Source)
	at javax.swing.RepaintManager.paintDirtyRegions(Unknown Source)
	at javax.swing.RepaintManager.seqPaintDirtyRegions(Unknown Source)
	at javax.swing.SystemEventQueueUtilities$ComponentWorkRequest.run(Unknown Source)
	at java.awt.event.InvocationEvent.dispatch(Unknown Source)
	at java.awt.EventQueue.dispatchEvent(Unknown Source)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.run(Unknown Source)

 

[Tomate_Salat]

ich meine dass

public Color getCellColor(int x, int y) {
        if(x >= 0 && x<= width && y >= 0 && y <= height) {
            return field[x][y].getCellColor();
        }
        return null;
    }

null zurückliefert, wenn die Bälle entfernt werden.

 

[japa]

OHHHHHH

DANKE

Es hat geklappt, so einfach und es ist mir nicht eingefallen.

Ich kenne ich einen Datentyp mehr.

 

[Tomate_Salat]

na dann, freut mcih wenn ich helfen konnte ;-)