Wie kann ich ein Hintergrundbild in Java einstellen?
Ich entwickle ein einfaches Plattformspiel, das Java verwendet, wobei BlueJ als IDE verwendet wird. Im Moment habe ich Spieler/Feind-Sprites, Plattformen und andere Gegenstände im Spiel, die mit Polygonen und einfachen Formen gezeichnet werden. Schließlich hoffe ich, sie durch tatsächliche Bilder zu ersetzen.
Im Moment würde ich gerne wissen, was die einfachste Lösung ist, um ein Bild (entweder eine URL oder eine lokale Quelle) als Hintergrund für mein Spielfenster/meine Leinwand festzulegen.
Ich würde es schätzen, wenn es nicht etwas langwierig oder komplex ist, da meine Programmierkenntnisse nicht sehr gut sind und ich mein Programm so einfach wie möglich halten möchte. Stellen Sie bitte Beispielcodes mit Kommentaren zur näheren Erläuterung ihrer Funktion zur Verfügung, und auch, wenn es sich in ihrer eigenen Klasse befindet, wie relevante Methoden in anderen Klassen verwendet werden.
Vielen Dank.
Die Antwort variiert geringfügig, je nachdem, ob die Anwendung oder das Applet AWT oder Swing verwendet.
（Grundsätzlich sind Klassen, die mit J beginnen, wie JApplet und JFrame, Swing und Applet und Frame sind AWT.)
In beiden Fällen wären die grundlegenden Schritte:
- Zeichnen oder laden Sie ein Bild in ein
Image-Objekt. - Zeichnen Sie das Hintergrundbild im Malereignis der
Component, in der Sie den Hintergrund zeichnen möchten.
Schritt 1. Das Laden des Bildes kann entweder mit der Toolkit Klasse oder mit der ImageIO Klasse erfolgen.
Die Methode Toolkit.createImage kann verwendet werden, um eine Image von einem in einer String angegebenen Ort zu laden:
Image img = Toolkit.getDefaultToolkit().createImage("background.jpg");
Ebenso kann ImageIO verwendet werden:
Image img = ImageIO.read(new File("background.jpg");
Schritt 2. Die Malmethode für die Component, die den Hintergrund erhalten soll, muss überschrieben werden. Malen Sie die Image auf die Komponente.
Für AWT ist die zu überschreibende Methode die Paint -Methode. Verwenden Sie die drawImage -Methode des Graphics - Objekts, das an die Paint-Methode übergeben wird:
public void Paint(Graphics g)
{
// Draw the previously loaded image to Component.
g.drawImage(img, 0, 0, null);
// Draw sprites, and other things.
// ....
}
Für Swing ist die zu überschreibende Methode die paintComponent -Methode der JComponent und zeichnet die Image wie mit dem, was in AWT gemacht wurde.
public void paintComponent(Graphics g)
{
// Draw the previously loaded image to Component.
g.drawImage(img, 0, 0, null);
// Draw sprites, and other things.
// ....
}
Einfaches Komponentenbeispiel
Hier ist eine Panel, die eine Bilddatei lädt, wenn sie instanziert wird, und dieses Bild auf sich selbst zeichnet:
class BackgroundPanel extends Panel
{
// The Image to store the background image in.
Image img;
public BackgroundPanel()
{
// Loads the background image and stores in img object.
img = Toolkit.getDefaultToolkit().createImage("background.jpg");
}
public void Paint(Graphics g)
{
// Draws the img to the BackgroundPanel.
g.drawImage(img, 0, 0, null);
}
}
Weitere Informationen zum Malen:
- Malen in AWT und Swing
- Lektion: Benutzerdefiniertes Malen durchführen von Die Java-Tutorials können hilfreich sein.
Erstellen Sie zunächst eine neue Klasse, die die WorldView-Klasse erweitert. Ich habe meine neue Klasse Background genannt. Importieren Sie also in dieser neuen Klasse alle Java-Pakete, die Sie zum Überschreiben der paintBackground-Methode benötigen. Das sollte sein:
import city.soi.platform.*;
import Java.awt.Graphics2D;
import Java.awt.Image;
import Java.awt.image.ImageObserver;
import javax.swing.ImageIcon;
import Java.awt.geom.AffineTransform;
Stellen Sie nach dem Klassennamen sicher, dass er WorldView erweitert enthält. Etwas wie das:
public class Background extends WorldView
Dann deklarieren Sie das Variablenspiel vom Typ Game und eine Bildvariable vom Typ Image in etwa wie folgt:
private Game game;
private Image image;
Stellen Sie dann im Konstruktor dieser Klasse sicher, dass sich das Spiel vom Typ Game in der Signatur des Konstruktors befindet, und dass Sie im Aufruf von super die Variable WorldView initialisieren müssen, das Spiel initialisieren und die Bildvariablen initialisieren müssen, z.
super(game.getCurrentLevel().getWorld(), game.getWidth(), game.getHeight());
this.game = game;
bg = (new ImageIcon("lol.png")).getImage();
Dann überschreiben Sie einfach die paintBackground-Methode auf dieselbe Weise wie beim Überschreiben der Paint-Methode in der Player-Klasse. Genau wie dieser:
public void paintBackground(Graphics2D g)
{
float x = getX();
float y = getY();
AffineTransform transform = AffineTransform.getTranslateInstance(x,y);
g.drawImage(bg, transform, game.getView());
}
Jetzt müssen Sie endlich einen Klassenebenenverweis auf die neue Klasse deklarieren, die Sie gerade in der Game-Klasse erstellt haben, und diese im Konstruktor Game initialisieren, etwa wie folgt:
private Background image;
And in the Game constructor:
image = new Background(this);
Zum Schluss müssen Sie nur noch den Hintergrund zum Rahmen hinzufügen! Ich bin sicher, dass wir alle vermisst haben. Dazu müssen Sie etwas tun, nachdem die Variable frame deklariert wurde:
frame.add(image);
Stellen Sie sicher, dass Sie diesen Code kurz vor frame.pack();..__ hinzufügen. Stellen Sie außerdem sicher, dass Sie ein Hintergrundbild verwenden, das nicht zu groß ist!
Jetzt ist es soweit! Ich habe bemerkt, dass die Game Engines JPEG- und PNG-Bildformate verarbeiten können, aber auch andere. Auch wenn dadurch ein Hintergrundbild in Ihr Spiel eingefügt wird, ist es nicht perfekt! Denn sobald Sie zum nächsten Level gelangen, sind alle Ihre Plattformen und Sprites unsichtbar und alles, was Sie sehen können, ist Ihr Hintergrundbild und alle JLabels/Jbuttons, die Sie im Spiel enthalten haben.
<script>
function SetBack(dir) {
document.getElementById('body').style.backgroundImage=dir;
}
SetBack('url(myniftybg.gif)');
</script>
Oder probiere es aus;)
try {
this.setContentPane(
new JLabel(new ImageIcon(ImageIO.read(new File("your_file.jpeg")))));
} catch (IOException e) {};