eclipse Java, bilder benutzten Funktioniert nicht

[needhelp___]

Hallo, ich bin zurzeit dabei ein kleines Spiel zu programmieren, (8bit,2D, also nicht wirklich etwas außergewöhnliches 🙂 ). Jedoch habe ich ein Problem, ein Bild das ich einfügen möchte, kann ich irgendwie nicht einfügen. Ich bekomme dabei auch keine Fehlermeldung oder sonstiges. Ich habe auch schon im Internet gesucht und nichts gefunden. Kann es sein das ich eventuell etwas bei eclpise verstellt habe? oder hab ich irgendwo was in dem Code vergessen?
danke schonmal im vorraus

package package1;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import javax.swing.JLabel;
public class Label extends JLabel{


private static final long serialVersionUID = 1L;
ImageLaden laden = new ImageLaden();
protected void Paint(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D)g;
super.paintComponent(g);
g2d.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

g.drawImage(ImageLaden.imageee, 0, 0,Variablen.breite,Variablen.höhe, labelFor);
repaint();
}
}


package package1;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
public class ImageLaden {
static BufferedImage imageee;


public ImageLaden() {

try {
imageee=ImageIO.read(new File("resc/rec/gem2.png"));
} catch (IOException e) {
System.out.println("alarm");
e.printStackTrace();
}

}
}


package package1;
import java.awt.Label;
import javax.swing.JFrame;
public class Gui {
JFrame Jfr1;

public Gui() {
Jfr1 = new JFrame();
Jfr1.setSize(Variablen.breite, Variablen.höhe);
Jfr1.setLocationRelativeTo(null);
Jfr1.setResizable(false);
Jfr1.requestFocus();
Jfr1.setVisible(true);
Jfr1.setTitle("Live in the woods");

Variablen.lab = new Label();
Variablen.lab.setBounds(0, 0, Variablen.breite, Variablen.höhe);
Variablen.lab.setVisible(true);
Jfr1.add(Variablen.lab);
}
}

 

[krgewb]

Bitte immer in code-Tags posten.

package package1;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import javax.swing.JLabel;

public class Label extends JLabel{

    private static final long serialVersionUID = 1L;
    ImageLaden laden = new ImageLaden();

    protected void Paint(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
        super.paintComponent(g);
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        g.drawImage(ImageLaden.imageee, 0, 0, Variablen.breite, Variablen.höhe, labelFor);
        repaint();
    }
}

package package1;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class ImageLaden {
    static BufferedImage imageee;

    public ImageLaden() {

        try {
            imageee = ImageIO.read(new File("resc/rec/gem2.png"));
        } catch (IOException e) {
            System.out.println("alarm");
            e.printStackTrace();
        }

    }
}

package package1;

import java.awt.Label;
import javax.swing.JFrame;

public class Gui {
    JFrame Jfr1;

    public Gui() {
        Jfr1 = new JFrame();
        Jfr1.setSize(Variablen.breite, Variablen.höhe);
        Jfr1.setLocationRelativeTo(null);
        Jfr1.setResizable(false);
        Jfr1.requestFocus();
        Jfr1.setVisible(true);
        Jfr1.setTitle("Live in the woods");

        Variablen.lab = new Label();
        Variablen.lab.setBounds(0, 0, Variablen.breite, Variablen.höhe);
        Variablen.lab.setVisible(true);
        Jfr1.add(Variablen.lab);
    }
}

 

[krgewb]

Du hast

g.drawImage(ImageLaden.imageee, 0, 0, Variablen.breite, Variablen.höhe, labelFor);

anstelle von

g.drawImage(laden.imageee, 0, 0, Variablen.breite, Variablen.höhe, labelFor);

 

[krgewb]

Wenn du es statisch lassen willst, musst du keinen Konstruktor verwenden, sondern einen "static block".

static {
    // hier dein Code
}

 

[thecain]

Und schon wieder "das" Tutorial...

 

[Blender3D]

Hallo, ich bin zurzeit dabei ein kleines Spiel zu programmieren

Du solltest Dir einen Gameloop bauen der immer nur ein Image zeichnet.

der Loop:
1) Positionen der Grafiken ändern.
2) Neue Positionen in das Buffer Image zeichnen.
3) Das Image vom System zeichnen lassen.
4) Warten
5) gehe zurück zu 1)
Ich habe Dir eine abstrakte Basisklasse GamePanel gemacht, die einen Gameloop realisiert.
Wie Du die Klasse GamePanel verwenden kannst wird im folgenden Beispiel mit Bällen die am Rand abprallen demonstriert.

import javax.swing.JFrame;
public class start {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Ball Panel");
        BallPanel game = new BallPanel(500, 500, 80);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.add(game);
        frame.pack();
        frame.setVisible(true);
        game.start();
    }
}

import java.awt.Color;
import java.awt.Dimension;
import java.util.Random;
@SuppressWarnings("serial")
public class BallPanel extends GamePanel {
    public final static Random rnd = new Random(System.currentTimeMillis());
    private Ball[] balls = new Ball[4];

    public BallPanel(int width, int height, int fps) {
        super(width, height, fps);
        setPreferredSize(new Dimension(width, height));
        for (int i = 0; i < balls.length; i++) {
            balls[i] = new Ball(getRandomInt(10, 45));
            balls[i].setPosition(getRandomInt(10, 300), getRandomInt(10, 300));
            balls[i].setSpeed(getRandomFloat(0, 2), getRandomFloat(0, 2));
        }
    }
    private float getRandomFloat(int min, int max) {
        return getRandomInt(min, max - 1) + rnd.nextFloat();
    }
    private int getRandomInt(int min, int max) {
        return rnd.nextInt(max - min) + min + 1;
    }
    @Override
    protected void render() {
        g2D.setColor(Color.BLACK);
        g2D.fillRect(0, 0, WIDTH, HEIGHT); // clear screen
        for (Ball b : balls)
            b.draw(g2D);
    }
    @Override
    protected void update() {
        for (Ball b : balls) {
            b.reflectBallAtScreenLimits(WIDTH, HEIGHT);
            b.move();
        }
    }
}

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;
/**
 * Abstract basis class for game's loop. For game's logic use {@link #update()}.
 * For graphic's manipulation use {@link #render()}.
 */
@SuppressWarnings("serial")
public abstract class GamePanel extends JPanel implements Runnable {
    /**
     * Graphic object to draw game's stuff.
     */
    protected final Graphics2D g2D;
    private BufferedImage image;
    private boolean paused = false;
    private boolean running = false;
    private int targetTime; // target time for sleeping
    private Thread thread;
    public final int WIDTH;
    public final int HEIGHT;
    /**
     * @param width
     *            Screen's width.
     * @param height
     *            Screen's height.
     * @param fps
     *            Frames per seconds.
     */
    public GamePanel(int width, int height, int fps) {
        this.WIDTH = width;
        this.HEIGHT = width;
        targetTime = 1000 / fps;
        image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
        g2D = image.createGraphics();
        g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    }
    /**
     * Don't override this method.
     *
     * @see #render()
     */
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (image != null)
            g.drawImage(image, 0, 0, null);
    }
    /**
     * Override for graphical manipulations. Use {@link #g2D}
     */
    abstract protected void render();
    @Override
    public void run() {
        long startTime;
        long elapsed;
        long wait;
        while (running) {
            startTime = System.nanoTime();
            if (!paused) {
                update();
                render();
                repaint();
            }
            elapsed = System.nanoTime() - startTime;
            wait = targetTime - elapsed / 1000000;
            if (wait > 0) {
                try {
                    Thread.sleep(wait);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public void setPaused(boolean paused) {
        this.paused = paused;
    }
    public void start() {
        stop();
        thread = new Thread(this);
        running = true;
        thread.start();
    }
    public void stop() {
        running = false;
        if (thread != null)
            while (thread.isAlive())
                ;
        thread = null;
    }
    /**
     * Override for game's logic.
     */
    abstract protected void update();
}

import java.awt.Color;
import java.awt.Graphics2D;
public class Ball {
    private float x;
    private float y;
    private float dx;
    private float dy;
    public final int size;
    public Ball(int size) {
        this.size = size;
    }
    public void draw(Graphics2D g) {
        g.setColor(Color.LIGHT_GRAY);
        int x = (int) this.x;
        int y = (int) this.y;
        g.fillOval(x, y, size, size);
        g.setColor(Color.WHITE);
        int glow = size / 4;
        g.fillOval(x + glow, y + glow, glow, glow);
    }
    public void move() {
        x += dx;
        y += dy;
    }
    public boolean reflectBallAtScreenLimits(int width, int height) {
        boolean ok = false;
        if (x <= 0 || x >= width - size) {
            dx = -dx;
            ok = true;
        }
        if (y <= 0 || y >= height - size) {
            dy = -dy;
            ok = true;
        }
        return ok;
    }

    public void setPosition(float x, float y) {
        this.x = x;
        this.y = y;
    }

    public void setSpeed(float dx, float dy) {
        this.dx = dx;
        this.dy = dy;
    }
}

😉

 

[needhelp___]

ey danke für die vielen guten antworten, werde es gleich mal umsetzen 🙂