# Billard



## Löffler (7. Jan 2010)

Hallo

ich versuche mich gerade an einem kleinem Billard Spiel. Ich habe mich an ein Bsp gehalten (Balzert, Das Billard Projekt) . Nun will ich aber gerne das der Queue vom Aussehen her änderbar ist. Dieser wird erstmal gezeichnet über die java eigenen draw Werkzeuge. Das würde ich auch gerne so lassen, da so wie er gezeichnet ist erstmal gut funktioniert. Nun würde ich aber gerne ein jpeg/png Bild über diese Zeichnung "drüberlegen" . Die Fuktionsweise des Queue soll aber die gleiche bleiben. So das ich nachher im fertigen Spiel das Aussehen des Queue schnell ändern kann mit verschiedenen Bildern. Gibt es da ne Möglichkeit das zu bewerkstelligen?


```
import java.awt.*;

public class Queue extends Component implements Runnable {
	public double xPos, yPos;
	public double xRichtung, yRichtung;

	private double xRichtungNormalisiert, yRichtungNormalisiert;
	private double stossstärke, ausholspeed, rücklaufspeed;
	private double xRichtungKugelNeu, yRichtungKugelNeu;

	private double stossmax = 500;
	private double länge = 200;
	private boolean sichtbar;
	private Kugel Spielkugel;
	private Thread t;
	private Image Queuebild;

	public Queue(Kugel sp) {
		Spielkugel = sp;
		stossstärke = Spielkugel.radius;
		Queuebild = getToolkit().getImage("queue_klein.png");
		MediaTracker tracker = new MediaTracker(this);
		tracker.addImage(Queuebild, 0);
	}

	public void starteAusholen() {
		rücklaufspeed = 0;
		ausholspeed = 1.5;
		t = new Thread(this);
		t.start();
		sichtbar = true;
	}

	public void stoppeAusholen() {
		double speed = java.lang.Math.sqrt(xRichtung * xRichtung + yRichtung
				* yRichtung);
		xRichtungNormalisiert = xRichtung * (1 / speed);
		yRichtungNormalisiert = yRichtung * (1 / speed);

		xRichtungKugelNeu = xRichtungNormalisiert
				* (stossstärke - Spielkugel.radius) * 0.1;
		yRichtungKugelNeu = yRichtungNormalisiert
				* (stossstärke - Spielkugel.radius) * 0.1;

		ausholspeed = 1;
		rücklaufspeed = -1;
	}

	public void run() {

		stossstärke = Spielkugel.radius;
		sichtbar = true;
		while (stossstärke >= Spielkugel.radius) {

			if (stossstärke < stossmax) {
				stossstärke *= ausholspeed;
			}

			stossstärke += rücklaufspeed;

			if (rücklaufspeed < 0) {
				rücklaufspeed *= 1.1;
				// der Queue soll beim rüchlauf beschleunigen.
			}

			try {
				Thread.sleep((long) (1000 / 25));
			} catch (InterruptedException e) {
			}

		}

		Spielkugel.xSpeed = xRichtungKugelNeu;
		Spielkugel.ySpeed = yRichtungKugelNeu;
		sichtbar = false;
		stossstärke = Spielkugel.radius;
	}

	public void paint(Graphics g) {
		xPos = Spielkugel.xPosition;
		yPos = Spielkugel.yPosition;
		double speed = java.lang.Math.sqrt(xRichtung * xRichtung + yRichtung
				* yRichtung);
		xRichtungNormalisiert = xRichtung * (1 / speed);
		yRichtungNormalisiert = yRichtung * (1 / speed);

		Tisch derTisch = Tisch.getInstance();
		// g.drawImage(Queuebild,(int) Spielkugel.xPosition,(int)
		// Spielkugel.yPosition,this);
		g.setColor(Color.red);
		// Stoßstärke - Balken malen
		g.fillRect(
						derTisch.getKanteLinks().x,
						derTisch.getKanteRechts().y + 20,
						(int) ((stossstärke)
								* ((derTisch.getSize().width + 2 * Spielkugel.radius) / stossmax) - 3 * Spielkugel.radius),
						(int) 20);
		// Polygonkoordinaten für das Queue berechnen
		int[] xes = {
				(int) (xPos - (xRichtungNormalisiert * stossstärke) + yRichtungNormalisiert * 3),
				(int) (xPos - (xRichtungNormalisiert * stossstärke) - yRichtungNormalisiert * 3),
				(int) (xPos - (xRichtungNormalisiert * (stossstärke + länge)) - yRichtungNormalisiert * 6),
				(int) (xPos - (xRichtungNormalisiert * (stossstärke + länge)) + yRichtungNormalisiert * 6) };

		int[] yes = {
				(int) (yPos - (yRichtungNormalisiert * stossstärke) - xRichtungNormalisiert * 3),
				(int) (yPos - (yRichtungNormalisiert * stossstärke) + xRichtungNormalisiert * 3),
				(int) (yPos - (yRichtungNormalisiert * (stossstärke + länge)) + xRichtungNormalisiert * 6),
				(int) (yPos - (yRichtungNormalisiert * (stossstärke + länge)) - xRichtungNormalisiert * 6) };
		// zuerst die Füllfarbe des Queues malen
		g.setColor(Color.orange);
		g.fillPolygon(xes, yes, xes.length);
		// dann die Umrandung
		g.setColor(Color.black);
		g.drawPolygon(xes, yes, xes.length);

		// Polygonkoordinaten für die Spitze berechnen
		int[] xos = {
				(int) (xPos - (xRichtungNormalisiert * stossstärke) + yRichtungNormalisiert * 3),
				(int) (xPos - (xRichtungNormalisiert * stossstärke) - yRichtungNormalisiert * 3),
				(int) (xPos - (xRichtungNormalisiert * (stossstärke + 30)) - yRichtungNormalisiert * 4),
				(int) (xPos - (xRichtungNormalisiert * (stossstärke + 30)) + yRichtungNormalisiert * 4) };

		int[] yos = {
				(int) (yPos - (yRichtungNormalisiert * stossstärke) - xRichtungNormalisiert * 3),
				(int) (yPos - (yRichtungNormalisiert * stossstärke) + xRichtungNormalisiert * 3),
				(int) (yPos - (yRichtungNormalisiert * (stossstärke + 30)) + xRichtungNormalisiert * 4),
				(int) (yPos - (yRichtungNormalisiert * (stossstärke + 30)) - xRichtungNormalisiert * 4) };
		// Spitze malen
		g.fillPolygon(xos, yos, xos.length);

		// Zielhilfe malen
		g.drawLine((int) (xPos + (xRichtungNormalisiert * Spielkugel.radius)),
				(int) (yPos + (yRichtungNormalisiert * Spielkugel.radius)),
				(int) (xPos + (xRichtungNormalisiert * (200 * 3))),
				(int) (yPos + (yRichtungNormalisiert * (200 * 3))));

	}

	public boolean sichtbarkeit() {
		return sichtbar;
	}
}
```


----------



## javimka (7. Jan 2010)

Das Bild kannst du ganz einfach darüber zeichnen, indem du am Schluss
[c]g.drawImage(queueBild,x,y,null);[/c]
anhängst. Variabeln schreibt man übrigens gemäss Konvention klein.


----------



## Löffler (7. Jan 2010)

danke erstmal für deine schnelle Antwort

habs jetzt mal probiert mit g.drawImage, nur meckert da eclipse bisschen rum

"The method drawImage(Image, int, int, ImageObserver) in the type Graphics is not applicable for the arguments (Image, int[], int[], null)"

mit g.drawLine würde es funktionieren, was mir aber nicht wirklich viel bringt...


----------



## javimka (7. Jan 2010)

Der Fehlermeldung entnehme ich, dass du keine einzelnen int als x und y übergeben hast, sondern jeweils ein ganzes Array. Soll denn an jedem dieser Punkte dieses Bild gezeichnet werden? Dann müsstest du das ganze in eine for-Schleife stecken und für jedes paar deiner zwei Arrays einmal das Bild zeichnen.


----------



## Löffler (7. Jan 2010)

ja habe ich da es mehrere Schritte waren für x und y und so habe ich das gleich in ein Array verpackt.


bevor ich da ne for schleife noch einfüge werd ich mal sehen das ich für x und y jeweils nur einen int wert gebe, sollte die Sache einfacher machen

```
int[] xes = {
				(int) (xPos - (xRichtungNormalisiert * stossstärke) + yRichtungNormalisiert * 3),
				(int) (xPos - (xRichtungNormalisiert * stossstärke) - yRichtungNormalisiert * 3),
				(int) (xPos - (xRichtungNormalisiert * (stossstärke + länge)) - yRichtungNormalisiert * 6),
				(int) (xPos - (xRichtungNormalisiert * (stossstärke + länge)) + yRichtungNormalisiert * 6) };

		int[] yes = {
				(int) (yPos - (yRichtungNormalisiert * stossstärke) - xRichtungNormalisiert * 3),
				(int) (yPos - (yRichtungNormalisiert * stossstärke) + xRichtungNormalisiert * 3),
				(int) (yPos - (yRichtungNormalisiert * (stossstärke + länge)) + xRichtungNormalisiert * 6),
				(int) (yPos - (yRichtungNormalisiert * (stossstärke + länge)) - xRichtungNormalisiert * 6) };
```


----------



## javimka (7. Jan 2010)

Die x,y Position, die du angibst, bezeichnet die linke obere Koordinate des ersten Pixels des Bildes.


----------



## Löffler (7. Jan 2010)

jo sind ja auch die Polygonkoordinaten, überlege gerade wie ich das am besten mache daraus nur 2 int Werte zu übergeben . (Wie gesagt habs halt grösstenteils nach einem Bsp von Balzert gemacht und bin auch noch nicht so "vertraut" mit java etc.. )

der rest wird ja mit set color etc gezeichnet


----------



## Löffler (8. Jan 2010)

ok nach etlichen rumprobieren kriege ich es nicht wirklich hin, das mit der for schleife is so ein ding da ich net weiss wie ich die innere Anweisung richtig deklarieren soll...
wäre schön wenn mir einer weiter hilft, das ganze ist auch aufgrund der arrays nicht gerade einfach


----------



## javimka (9. Jan 2010)

An welche x,y Position soll denn das Bild gezeichnet werden? Ich weiss nicht, was die Bedeutung deines Arrays ist. Wenn du das Bild an jede einzelne x,y Position aus den Arrays zeichnen willst (was du wahrscheinlich nicht willst), musst du schreiben

```
for (int i=0;i<arrayX.length;i++) {
  g.drawImage(queueBild,array1[i],array2[i],null);
}
```
Vielleicht willst du das Array auch einfach an die erste Position schreiben, also array1[0], array2[0].


----------



## Löffler (9. Jan 2010)

danke erstmal für deine Hilfe

jetzt zeigt er das Bild wenigstens schonmal an, nur leider nicht wirklich "deckend" . Das jetzige Bild ist auch nur nen Test Bild aber es müsste ja wenigstens über dem gezeichneten Queue liegen. Das sieht aber bis jetzt so aus:







```
for (int i=0;i<xes.length;i++) {
        	  g.drawImage(Queuebild,xes[0],yes[0],null);
        	}
```

Hier nochmal der gesamte Code der Klasse:

```
import java.awt.*;

public class Queue extends Component implements Runnable
{
    public double xPos,yPos;
    public double xRichtung, yRichtung;

    private double xRichtungNormalisiert, yRichtungNormalisiert;
    private double stossstärke, ausholspeed, rücklaufspeed;
    private double xRichtungKugelNeu, yRichtungKugelNeu;
    private int hilfe;
    private double stossmax = 300;
    private double länge   = 200;
    private boolean sichtbar;
    private Kugel Spielkugel;
    private Thread t;
    private Image Queuebild;
    
    public Queue(Kugel sp)
    {
        Spielkugel = sp;
        stossstärke = Spielkugel.radius;     
        Queuebild = getToolkit().getImage( "queue_klein.png" );
	    MediaTracker tracker = new MediaTracker(this);
	    tracker.addImage(Queuebild, 0);
    }
    
    public void starteAusholen()
    {
        rücklaufspeed = 0;
        ausholspeed   = 1.3;
        t=new Thread(this);
        t.start();
        sichtbar=true;
    }
    
    public void stoppeAusholen()
    {      
        double speed=java.lang.Math.sqrt(xRichtung*xRichtung+yRichtung*yRichtung);
        xRichtungNormalisiert=xRichtung*(1/speed);
        yRichtungNormalisiert=yRichtung*(1/speed);
        
        xRichtungKugelNeu=xRichtungNormalisiert*(stossstärke-Spielkugel.radius)*0.1;
        yRichtungKugelNeu=yRichtungNormalisiert*(stossstärke-Spielkugel.radius)*0.1;
        hilfe = 2;
        ausholspeed=1;
        rücklaufspeed=-1;        
    }
    public void run()
    {

        
        stossstärke=Spielkugel.radius;
        sichtbar=true;
        hilfe = 0;
        while (stossstärke >= Spielkugel.radius)
        {
        	 if (hilfe == 1)
             {	
             	stossstärke-=15;
             	if (stossstärke <= Spielkugel.radius)
             	{
             		stossstärke= Spielkugel.radius;
             		hilfe = 0;
             	}
             }
            if (hilfe == 0)
            {
            	stossstärke*=ausholspeed;
            	if (stossstärke >= stossmax)
            	{
            		hilfe = 1;
            		
            	}
            }
           
            
            stossstärke+=rücklaufspeed;    
            
            if (rücklaufspeed<0)
            {
              	rücklaufspeed*=1.1;
              	// der Queue soll beim rüchlauf beschleunigen.
            }
            
            try {Thread.sleep((long)(1000/24));}
            catch (InterruptedException e){}
            
        }

        Spielkugel.xSpeed=xRichtungKugelNeu;
        Spielkugel.ySpeed=yRichtungKugelNeu;
        sichtbar=false;
        stossstärke=Spielkugel.radius;
    }
    
    
    public void paint(Graphics g)
    {
        xPos=Spielkugel.xPosition;
        yPos=Spielkugel.yPosition;
        double speed=java.lang.Math.sqrt(xRichtung*xRichtung+yRichtung*yRichtung);
        xRichtungNormalisiert=xRichtung*(1/speed);
        yRichtungNormalisiert=yRichtung*(1/speed);
       
        Tisch derTisch = Tisch.getInstance();
       // g.drawImage(Queuebild,(int) Spielkugel.xPosition,(int) Spielkugel.yPosition,this);
        g.setColor(Color.BLACK);
        // Stoßstärke - Balken malen
        g.fillRoundRect( derTisch.getKanteLinks().x,
                derTisch.getKanteRechts().y + 150,
               (int)(((stossstärke)*(( derTisch.getSize().width +2*Spielkugel.radius)/stossmax)-3*Kugel.radius))*2/3,
               (int)20,22,22);
       // Polygonkoordinaten für das Queue berechnen
        int[] xes={(int)(xPos-(xRichtungNormalisiert*stossstärke)+yRichtungNormalisiert*3),
                   (int)(xPos-(xRichtungNormalisiert*stossstärke)-yRichtungNormalisiert*3),
                   (int)(xPos-(xRichtungNormalisiert*(stossstärke+länge))-yRichtungNormalisiert*6),
                   (int)(xPos-(xRichtungNormalisiert*(stossstärke+länge))+yRichtungNormalisiert*6)};
                 
        int[] yes={(int)(yPos-(yRichtungNormalisiert*stossstärke)-xRichtungNormalisiert*3),
                   (int)(yPos-(yRichtungNormalisiert*stossstärke)+xRichtungNormalisiert*3),
                   (int)(yPos-(yRichtungNormalisiert*(stossstärke+länge))+xRichtungNormalisiert*6),
                   (int)(yPos-(yRichtungNormalisiert*(stossstärke+länge))-xRichtungNormalisiert*6)};
        // zuerst die Füllfarbe des Queues malen
        g.setColor(Color.LIGHT_GRAY);
        g.fillPolygon(xes, yes, xes.length);
        // dann die Umrandung
        g.setColor(Color.black);
        g.drawPolygon(xes, yes, xes.length);
        
        //Polygonkoordinaten für die Spitze berechnen
        int[] xos={(int)(xPos-(xRichtungNormalisiert*stossstärke)+yRichtungNormalisiert*3),
                   (int)(xPos-(xRichtungNormalisiert*stossstärke)-yRichtungNormalisiert*3),
                   (int)(xPos-(xRichtungNormalisiert*(stossstärke+30))-yRichtungNormalisiert*4),
                   (int)(xPos-(xRichtungNormalisiert*(stossstärke+30))+yRichtungNormalisiert*4)};
                 
        int[] yos={(int)(yPos-(yRichtungNormalisiert*stossstärke)-xRichtungNormalisiert*3),
                   (int)(yPos-(yRichtungNormalisiert*stossstärke)+xRichtungNormalisiert*3),
                   (int)(yPos-(yRichtungNormalisiert*(stossstärke+30))+xRichtungNormalisiert*4),
                   (int)(yPos-(yRichtungNormalisiert*(stossstärke+30))-xRichtungNormalisiert*4)};
        // Spitze malen
        g.fillPolygon(xos, yos, xos.length);
        
        for (int i=0;i<xes.length;i++) {
        	  g.drawImage(Queuebild,xes[0],yes[0],null);
        	}

    }
    
    public boolean sichtbarkeit()
    {
        return sichtbar;
    }
}
```


----------



## javimka (9. Jan 2010)

Welches Bild ist denn die Queue und worüber müsste es liegen?

Du hast die g.drawImage Anweisung in eine for-Schleife geschrieben. Weil du immer an die Position xes[0],yes[0] zeichnest, ist das aber nicht nötig, du zeichnest hier einfach mehrere Male das gleiche Bild. Die for-Schleife solltest du löschen.

Gibt es einen Grund, wieso Queue nur von Component erbt und nicht von JComponent? Das wäre dann Swing, statt AWT, was dir viele Vorteile bringen kann. Falls du es änderst, müsstest du dann paintComponent(g) statt paint(g) überschreiben.


----------



## Löffler (9. Jan 2010)

also das graue ist der gezeichnete Queue, welcher "überdeckt" werden soll durch ein Bild.

Das Bild is in dem Fall erstmal noch nen Test Bild, man sieht ja das Bild viel schmaler ist als der gezeichnete Queue, ihn also noch nicht in vollem umfang überdecken kann.

Werde es denke mal noch in JComponent ändern, das Bsp aus dem ich das habe war halt noch in awt, so dass ich das erstmal so gelassen habe.

die for Schleife habe ich gelöscht, aber ändern tut sich nichts, es sieht weiterhin so aus wie auf dem Screenshot den ich erst gepostet habe.

Hier noch mal nen Code update, da ich hier und da Kleinigkeiten verändert habe:

```
import java.awt.*;

public class Queue extends Component implements Runnable {
	public double x;
	public double y;
	public double xRichtung;
	public double yRichtung;
	private double xRichtungnormal;
	private double yRichtungnormal;
	private double stossstärke;
	private double ausholsgeschwindigkeit;
	private double rücklaufgeschwindigkeit;
	private double xRichtungKugelNeu;
	private double yRichtungKugelNeu;
	private double stossmax = 300;
	private double länge = 200;
	private int hilfe;
	private boolean sichtbar;
	private Kugel spielkugel;
	private Thread t;
	private Image queuebild;


	public Queue(Kugel sp) {
		spielkugel = sp;
		stossstärke = spielkugel.radius;
		queuebild = getToolkit().getImage("queue_klein.png");
		MediaTracker tracker = new MediaTracker(this);
		tracker.addImage(queuebild, 0);
	}

	public void starteAusholen() {
		rücklaufgeschwindigkeit = 0;
		ausholsgeschwindigkeit = 1.3;
		t = new Thread(this);
		t.start();
		sichtbar = true;
	}

	public void stoppeAusholen() {
		double speed = java.lang.Math.sqrt(xRichtung * xRichtung + yRichtung
				* yRichtung);
		xRichtungnormal = xRichtung * (1 / speed);
		yRichtungnormal = yRichtung * (1 / speed);

		xRichtungKugelNeu = xRichtungnormal * (stossstärke - spielkugel.radius)
				* 0.1;
		yRichtungKugelNeu = yRichtungnormal * (stossstärke - spielkugel.radius)
				* 0.1;
		hilfe = 2;
		ausholsgeschwindigkeit = 1;
		rücklaufgeschwindigkeit = -1;
	}

	public void run() {

		stossstärke = spielkugel.radius;
		sichtbar = true;
		hilfe = 0;
		while (stossstärke >= spielkugel.radius) {
			if (hilfe == 1) {
				stossstärke -= 15;
				if (stossstärke <= spielkugel.radius) {
					stossstärke = spielkugel.radius;
					hilfe = 0;
				}
			}
			if (hilfe == 0) {
				stossstärke *= ausholsgeschwindigkeit;
				if (stossstärke >= stossmax) {
					hilfe = 1;

				}
			}

			stossstärke += rücklaufgeschwindigkeit;

			if (rücklaufgeschwindigkeit < 0) {
				rücklaufgeschwindigkeit *= 1.1;
				// der Queue soll beim rüchlauf beschleunigen.
			}

			try {
				Thread.sleep((long) (1000 / 24));
			} catch (InterruptedException e) {
			}

		}

		spielkugel.xGeschwindigkeit = xRichtungKugelNeu;
		spielkugel.yGeschwindigkeit = yRichtungKugelNeu;
		sichtbar = false;
		stossstärke = spielkugel.radius;
	}

	public void paint(Graphics g) {
		x = spielkugel.xPosition;
		y = spielkugel.yPosition;
		double speed = java.lang.Math.sqrt(xRichtung * xRichtung + yRichtung
				* yRichtung);
		xRichtungnormal = xRichtung * (1 / speed);
		yRichtungnormal = yRichtung * (1 / speed);

		Tisch derTisch = Tisch.getInstance();
		// g.drawImage(Queuebild,(int) Spielkugel.xPosition,(int)
		// Spielkugel.yPosition,this);
		g.setColor(Color.BLACK);
		// Stoßstärke - Balken malen
		g.fillRoundRect(
						derTisch.getKanteLinks().x,
						derTisch.getKanteRechts().y + 150,
						(int) (((stossstärke)
								* ((derTisch.getSize().width + 2 * spielkugel.radius) / stossmax) - 3 * Kugel.radius)) * 2 / 3,
						(int) 20, 22, 22);
		// Polygonkoordinaten für das Queue berechnen
		int[] xes = {
				(int) (x - (xRichtungnormal * stossstärke) + yRichtungnormal * 3),
				(int) (x - (xRichtungnormal * stossstärke) - yRichtungnormal * 3),
				(int) (x - (xRichtungnormal * (stossstärke + länge)) - yRichtungnormal * 6),
				(int) (x - (xRichtungnormal * (stossstärke + länge)) + yRichtungnormal * 6) };

		int[] yes = {
				(int) (y - (yRichtungnormal * stossstärke) - xRichtungnormal * 3),
				(int) (y - (yRichtungnormal * stossstärke) + xRichtungnormal * 3),
				(int) (y - (yRichtungnormal * (stossstärke + länge)) + xRichtungnormal * 6),
				(int) (y - (yRichtungnormal * (stossstärke + länge)) - xRichtungnormal * 6) };

		//Bild über den gezeichneten Queue legen
			g.drawImage(queuebild, xes[0], yes[0], null);
		

		// zuerst die Füllfarbe des Queues malen und dann die Umrandung
		g.setColor(Color.LIGHT_GRAY);
		g.fillPolygon(xes, yes, xes.length);
		g.setColor(Color.black);
		g.drawPolygon(xes, yes, xes.length);

		// Polygonkoordinaten für die Spitze berechnen
		int[] xos = {
				(int) (x - (xRichtungnormal * stossstärke) + yRichtungnormal * 3),
				(int) (x - (xRichtungnormal * stossstärke) - yRichtungnormal * 3),
				(int) (x - (xRichtungnormal * (stossstärke + 30)) - yRichtungnormal * 4),
				(int) (x - (xRichtungnormal * (stossstärke + 30)) + yRichtungnormal * 4) };

		int[] yos = {
				(int) (y - (yRichtungnormal * stossstärke) - xRichtungnormal * 3),
				(int) (y - (yRichtungnormal * stossstärke) + xRichtungnormal * 3),
				(int) (y - (yRichtungnormal * (stossstärke + 30)) + xRichtungnormal * 4),
				(int) (y - (yRichtungnormal * (stossstärke + 30)) - xRichtungnormal * 4) };

		g.fillPolygon(xos, yos, xos.length); // Spitze malen

	}

	public boolean sichtbarkeit() {
		return sichtbar;
	}
}
```


----------



## javimka (9. Jan 2010)

Dann ist das Problem augenscheinlich, dass das Bild nicht richtig gedreht ist, oder? Das Bild müsste um etwa 110° im Uhrzeigersinn gedreht werden. Das kannst du mit einer AffineTransform machen. Hier ist das beschrieben: Bild drehen - Java @ tutorials.de: Forum, Tutorial, Anleitung, Schulung & Hilfe


----------



## Löffler (9. Jan 2010)

also ich bin mir da nicht wirklich sicher ob einfach das Bild drehen, wirklich zur gewünschten Lösung führt. Aber ich hab es probiert und habe jetzt einige Probleme hinsichtlich der Drehung.

```
BufferedImage rotatedImage = new BufferedImage(queuebild.getHeight(null), queuebild.getWidth(null), ((BufferedImage) queuebild).getType());
		AffineTransform affineTransform = AffineTransform.getRotateInstance(Math.toRadians(110), rotatedImage.getWidth() / 2d, queuebild.getHeight(null) / 2d);
		Graphics2D h = (Graphics2D) rotatedImage.getGraphics();
		((Graphics2D) g).setTransform(affineTransform);
		g.drawImage(queuebild, xes[0], yes[0], null);
```



folgende Fehlermeldung bekomme ich da:

Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: sun.awt.image.ToolkitImage cannot be cast to java.awt.image.BufferedImage
	at Queue.paint(Queue.java:138)
	at Spielerklasse.paint(Spielerklasse.java:363)
	at Spielerklasse.update(Spielerklasse.java:342)
	at sun.awt.RepaintArea.updateComponent(Unknown Source)
	at sun.awt.RepaintArea.paint(Unknown Source)
	at sun.awt.windows.WComponentPeer.handleEvent(Unknown Source)
	at sun.awt.windows.WWindowPeer.handleEvent(Unknown Source)
	at java.awt.Component.dispatchEventImpl(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Window.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(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)

Wenn ich wüsste wie ich den Queue ohne das er durch die java werkzeuge gezeichnet wird, einfach gleich als Bild nehmen könnte wäre das auch OK. Nur habe ich davon auch keinen Schimmer wie ich das bewerstelligen müsste.

Nachtrag:

Wenn das Bild gedreht wurde hätte es ja nur eine andere Position, oder nicht?
Die Spitze des queue Bildes (das png Bild) ist ja auf der Position des gezeichneten Queue's. Sie hat die richtige Position. Nur das "Ende" des Bildes nicht. Die Spitze bewegt sich ja schon mit nur nicht das Queue ende. Ich müsste also die endkoordinate des Bildes auf die endkoordinate des gezeichneten Queue's setzen, oder?


----------



## javimka (9. Jan 2010)

Der Fehler kommt, weil du das Image nicht in einem BufferedImage casten kansnt: [c]((BufferedImage) queuebild[/c]
Verwende stattdessen als drittes Argument für das BufferedImage [c]Transparency.TRANSLUCENT[/c]

Vielleicht habe ich immer noch nicht verstanden, was du möchtest. Ich dachte, das zurzeit vertikale Bild soll gedreht und über das grau/schwarze Gezeichnete gelegt werden. Falls das so ist, musst du das Bild drehen und du musst die Pixelkoordinate oben/links finden, wo das Bild hinsoll.


----------



## Löffler (9. Jan 2010)

javimka hat gesagt.:


> Vielleicht habe ich immer noch nicht verstanden, was du möchtest. Ich dachte, das zurzeit vertikale Bild soll gedreht und über das grau/schwarze Gezeichnete gelegt werden. Falls das so ist, musst du das Bild drehen und du musst die Pixelkoordinate oben/links finden, wo das Bild hinsoll.



Nein das ist richtig, aber der Queue(gezeichnet bzw der grau/scharze) bewegt sich ja um die Weisse Kugel, 360 Grad. Die Spitze des png Bildes wandert so wie es jetzt is mit rum. Nur bleibt das restliche png Bild in seiner starren Position.
Ich möchte halt das das png Bild nachher den grau/scharz gezeichneten Queue Überdeckt, ich also als Queue ein Bild verwende und nicht das gezeichnete.

*edit*

so habe jetzt den Transparency.TRANSLUCENT Befehl eingefügt, nun wird aber das halbe fenster gedreht. Eigentlich sollte ja nur das Queue Bild gedreht werden 

Ich danke dir trotzdem erstmal, das du dir die Zeit nimmst um mir hier zu helfen, was sicher nicht ganz so einfach ist


----------

