Wie Hintergrundgrafiken in Java zu stoppen?

Question

Ich versuche, ein einfaches Java-Spiel zu machen. Es funktioniert gut, aber ich einen Hintergrund zeichnen, aber ich habe nicht Platz der Farbe zu stoppen, ist es immer

ändern schreibe ich eine andere Klasse für das, und ich nenne es in Haupt, aber ich habe es nicht

work @ SuppressWarnings („serial“)

class BackPan extends JFrame{ 


    private JLayeredPane layers; 
    private JPanel down; 
    static int width = Board.boardWidth; 
    static int height = Board.boardHeight; 
    Random rnd = new Random(); 

    public BackPan(){ 

      layers = new JLayeredPane(); 
      rnd =new Random(); 
      down = new JPanel(){ 
      public void paintComponent(Graphics g){ 
      Graphics2D g2d = (Graphics2D)g; 
      //*************************************************************** 
      int low = 50; 
      int high = 255; 
      for(int i = 0; i<= width; i+=50){ 
       g2d.setColor(new Color(rnd.nextInt(high-low)+low,rnd.nextInt(high-low)+low,rnd.nextInt(high-low)+low));    
       g2d.fillRect(i, 50, 50, 50); 
       for(int j = 0; j<= height; j += 50){ 
        g2d.setColor(new Color(rnd.nextInt(high-low)+low,rnd.nextInt(high-low)+low,rnd.nextInt(high-low)+low)); 
        g2d.fillRect(i, j, 50, 50);     
       } 
      } 
      } 
      }; 
      //**************************************************************** 
      down.setBounds(0, 0, width, height); 
      layers.add(down, new Integer(1)); 
      getContentPane().add(layers, BorderLayout.CENTER); 


    } 

} 

Answer 1

besser als ein Satz Samt für Ihre Randomisierung verwenden, fixieren Sie einfach das zufällige Bild durch eine von zwei Möglichkeiten:

1. eine Reihe von Farben erstellen, die Sie bei Bedarf Randomisierung und dann verwenden Dieses Array beim Zeichnen des Hintergrunds
2. Noch besser, einfach zeichnen Sie Ihre zufälligen Farben zu einem BufferedImage und zeichnen das in der PaintComponent-Methode. Wenn dies erneut randomisiert werden muss, erstellen Sie das Bild erneut.

Ein Beispiel für letztere ist zu beachten, dass der Bildwieder randomisiert nur, wenn Sie die Taste (durch den Aufruf die createBackground() Methode) gedrückt wird:

import java.awt.Color; 
import java.awt.Dimension; 
import java.awt.Graphics; 
import java.awt.Image; 
import java.awt.event.ActionEvent; 
import java.awt.image.BufferedImage; 
import javax.swing.*; 

@SuppressWarnings("serial") 
public class ColorSquares extends JPanel { 
    public static final int SQR_SIDE = 50; 
    public static final int COLUMNS = 20; 
    public static final int ROWS = 16; 
    private int columns; 
    private int rows; 
    private int sqrSide; 
    private Image backgroundImg;  

    public ColorSquares(int columns, int rows, int sqrSide) { 
     this.columns = columns; 
     this.rows = rows; 
     this.sqrSide = sqrSide; 
     backgroundImg = createBackground(); 
     add(new JButton(new AbstractAction("New Background") { 

      @Override 
      public void actionPerformed(ActionEvent arg0) { 
       backgroundImg = createBackground(); 
       repaint(); 
      } 
     })); 
    } 

    public Image createBackground() { 
     int w = columns * sqrSide; 
     int h = rows * sqrSide; 
     BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); 
     Graphics g = img.getGraphics(); 
     for (int r = 0; r < rows; r++) { 
      for (int c = 0; c < columns; c++) { 
       float hue = (float) Math.random(); 
       float saturation = (float) (Math.random() * 0.5 + 0.5); 
       float brightness = (float) (Math.random() * 0.5 + 0.5); 
       Color randColor = Color.getHSBColor(hue, saturation, brightness); 
       g.setColor(randColor); 
       int x = c * sqrSide; 
       int y = r * sqrSide; 
       g.fillRect(x, y, sqrSide, sqrSide); 
      } 
     } 
     g.dispose(); 
     return img; 
    } 

    @Override 
    protected void paintComponent(Graphics g) { 
     super.paintComponent(g); 
     if (backgroundImg != null) { 
      g.drawImage(backgroundImg, 0, 0, this); 
     } 
    } 

    @Override 
    public Dimension getPreferredSize() { 
     if (isPreferredSizeSet()) { 
      return super.getPreferredSize(); 
     } 
     return new Dimension(columns * sqrSide, rows * sqrSide); 
    } 

    private static void createAndShowGui() { 
     JFrame frame = new JFrame("Colors"); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     frame.getContentPane().add(new ColorSquares(COLUMNS, ROWS, SQR_SIDE)); 
     frame.pack(); 
     frame.setLocationRelativeTo(null); 
     frame.setVisible(true); 
    } 

    public static void main(String[] args) { 
     SwingUtilities.invokeLater(() -> createAndShowGui()); 
    } 
} 

Ein weiterer Vorteil der Verwendung eines BufferedImage ist, dass es ist schneller, dies zu zeichnen, als Sie es tun.

Answer 2

Die einfachste Lösung wäre es, einen konstanten zufälligen Samen zu erinnern, und legen sie es über rnd.setSeed() jedes Mal paintComponent genannt wird. Zum Beispiel:

private final static int SEED = 1000; 
rnd.setSeed(SEED);