Swing: Raumshiff

[Adriano10]

package gif;

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;

public class MyPanel extends JPanel implements ActionListener {
    final int PANEL_WIDTH = 500;
    final int PANEL_HEIGHT = 500;
    Image enemy;
    Image backgroundImage;
    Timer timer;
    int xVelocity = 1;
    int yVelocity = 1;
    int x = 0;
    int y = 0;
    Graphics2D graphics2D;
    AffineTransform at;

    MyPanel() {
        this.setPreferredSize(new Dimension(PANEL_WIDTH, PANEL_HEIGHT));
        this.setBackground(Color.black);
        enemy = new ImageIcon(getClass().getResource("../image/raumShiff.png")).getImage();
        backgroundImage = new ImageIcon(getClass().getResource("../image/kos.jpg")).getImage();
        timer = new Timer(10, this);
        timer.start();
    }

    public void paint(Graphics g) {
        super.paint(g);
        //BufferedImage Image = LoadImage(getClass().getResource("../image/raumShiff.png"));
     /*   if (x >= PANEL_WIDTH - enemy.getWidth(null) || x < 0) {
            at = AffineTransform.getTranslateInstance(100, 100);
            at.rotate(Math.toRadians(180));
            graphics2D.setTransform(at);
        }*/
        graphics2D = (Graphics2D) g;
        graphics2D.drawImage(backgroundImage, 0, 0, null);
        graphics2D.drawImage(enemy, x, y, null);
    }

    private BufferedImage LoadImage(URL Filename) {
        BufferedImage image = null;

        try {
            image =  ImageIO.read(new File(Filename.toURI()));
        }catch (IOException | URISyntaxException e){

        }
        return image;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (x >= PANEL_WIDTH - enemy.getWidth(null) || x < 0) {
            xVelocity = xVelocity * (-1);
            y += 10;
            at = AffineTransform.getTranslateInstance(100, 100);
            at.rotate(Math.toRadians(180));
            graphics2D.transform(at);
        }
        x = x + xVelocity;
        repaint();
    }
}

Kann jemand mir bitte sagen, wie kann ich den Raumschiff um 180 Grad drehen, wenn in der Zeile 64 die Bedingung erfüllt ist.

Vielen Dank im Voraus

 

[Blender3D]

Kann jemand mir bitte sagen, wie kann ich den Raumschiff um 180 Grad drehen, wenn in der Zeile 64 die Bedingung erfüllt ist.

Ich kann habe dafür einmal eine Klasse (RotationImage) gemacht.
mittels

image.setAngle(degree)

kannst Du die Rotation einstellen. Zum Zeichen verwendetst Du

image.draw(g)

Hier ein Beispiel für diese Klasse.

import javax.swing.JFrame;

public class TestRotationImage {
    public static void main(String[] args) {
        JFrame frame = new JFrame("rotate");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new RotationPanel(500, 500));
        frame.pack();
        frame.setVisible(true);
    }
}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;

import javax.swing.JPanel;

@SuppressWarnings("serial")
public class RotationPanel extends JPanel implements Runnable {
    private RotationImage image;
    private boolean running;
    private Thread animator;

    public RotationPanel(int width, int height) {
        setPreferredSize(new Dimension(width, height));   
    }

    @Override
    public void addNotify() {
        super.addNotify();
        image = new RotationImage(getImage(100, 100));
        image.setPosition(100, 100);
        start();
    }

    private BufferedImage getImage(int width, int height) {
        BufferedImage img = (BufferedImage) createImage(width, height);
        Graphics g = img.getGraphics();
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, width, height);
        g.setColor(Color.WHITE);
        g.drawRect(1, 1, width - 2, height - 2);
        g.fillOval(width / 4, height / 4, width / 10, height / 10);
        g.dispose();
        return img;
    }

    @Override
    public void paintComponent(Graphics g) {
        g.fillRect(0, 0, getWidth(), getHeight());
        image.draw(g);
    }

    @Override
    public void run() {
        while (running) {
            image.setAngle(image.getAngle() + .5f);
            repaint();
            try {
                Thread.sleep(6);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void start() {
        running = false;
        while (animator != null && animator.isAlive())
            ;
        animator = new Thread(this);
        running = true;
        animator.start();
    }

    public void stop() {
        running = false;
    }
}

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;

public class RotationImage {
    private BufferedImage image;
    private float x = 0;
    private float y = 0;
    private float angle = 0;

    public RotationImage(BufferedImage image) {
        createImage(image);
    }

    private void createImage(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        int dim = (int) Math.sqrt(width * width + height * height);
        this.image = new BufferedImage(dim, dim, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2 = (Graphics2D) this.image.getGraphics();
        g2.setBackground(new Color(0, true));// transparent background
        g2.clearRect(0, 0, dim, dim);
        g2.drawImage(image, (dim - width) / 2, (dim - height) / 2, null);
        g2.dispose();
    }

    public void draw(Graphics g) {
        if (image == null)
            return;
        BufferedImage img = (angle != 0) ? getRotatedImage(image) : image;
        g.drawImage(img, (int) x, (int) y, null);
    }

    private BufferedImage getRotatedImage(BufferedImage img) {
        AffineTransform aT = AffineTransform.getRotateInstance(angle, img.getWidth() / 2, img.getHeight() / 2);
        AffineTransformOp op = new AffineTransformOp(aT, AffineTransformOp.TYPE_BILINEAR);
        return op.filter(img, null);
    }

    public float getAngle() {
        return (float) Math.toDegrees(angle);
    }

    public int getHeight() {
        return image.getHeight();
    }

    public int getWidth() {
        return image.getWidth();
    }

    public float getX() {
        return x;
    }

    public float getY() {
        return y;
    }

    public void setAngle(float angle) {
        this.angle = (float) Math.toRadians(angle % 360);
    }

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

 

[Adriano10]

Vielen Dank, sehr hilfreich

 

[Blender3D]

Vielen Dank, sehr hilfreich

In meinem obigen Code fehlt noch

public void paintComponent(Graphics g) {
        super.paintComponent(g); // hat oben gefehlt
        g.fillRect(0, 0, getWidth(), getHeight());
        image.draw(g);
    }

Noch ein Hinweis in deinem Code überschreibst Du die Methode

   public void paint(Graphics g)

Das ist nicht empfehlenswert.