# Hilfe! Java Applet



## Gast (14. Apr 2005)

HI, ich hab ein kleines Problem, unserer Leher hat uns den auftrag gegeben ein Fliegendes Dreieck zu zeichnen mit Hilfe eins Applets. Das dreieck soll von den 4 Seiten des Applets abprallen. Da ich mich aber nicht wirklihc auskenn mit applets wollte ich fragen ob mir da wer helfen könnte 

lg murmel


----------



## L-ectron-X (15. Apr 2005)

Wir machen keine Hausaufgaben, helfen aber gerne bei konkreten Fragen.
Dein Lehrer möchte, dass ihr etwas programmiert, aber er wird doch nichts verlangen, von dem ihr noch nie gehört habt, oder?
Was weißt Du denn schon, bzw. wo genau bist Du mit deinem Bemühungen hängen geblieben?


----------



## Sky (15. Apr 2005)

Mit dem Code

```
public class myApplet extends Applet {
}
```

bzw. 


```
public class myApplet extends JApplet {
}
```

erstellst Du ein Applet welches auf AWT bzw. Swing basisert. Dein Dreieck kannste hierin wie in einer Application fliegen lassen ;-)


----------



## Gast (15. Apr 2005)

```
import java.applet.*;
import java.awt.*;

public class Strichbegewegen extends Applet implements Runnable {  // Initialisierung der Variablen
    double x1_posa=2;
    double y1_posa=2;
    
    double x1_pos=50;
    double y1_pos=30;
    
    double y2_pos=0;
    double x2_pos=0;
    
    double x3_pos=0;
    double y3_pos=0;
    
    double winkelbeta=((Math.PI*-40)/180);
   
    int appletsize_x=300;
    int appletsize_y=200;
    
    private Image dbImage;
    private Graphics dbg;
    
    public void init()
    {setBackground(Color.BLUE);
     
    }
    
    public void start()
    { Thread th= new Thread(this);
      
      th.start();
    }
    
    public void stop() {
    }
    
    public void destroy() {
    }
    
    public void run()
    {	Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        double xsteig=x1_posa+Math.cos(winkelbeta)*1;
        double ysteig=y1_posa+Math.sin(winkelbeta)*1;
        x2_pos=x1_pos-(Math.sin(60)*15);
        y2_pos=y1_pos-(Math.cos(60)*15);
        x3_pos=x1_pos-(Math.cos(-60)*15);
        y3_pos=y1_pos-(Math.sin(-60)*15);
        while(true) {
            if ((x1_pos < 0) | (x1_pos > appletsize_x)|(x2_pos < 0)|(x3_pos < 0)| (x2_pos > appletsize_x)| (x3_pos > appletsize_x)) {
                xsteig=xsteig*-1;
            } // if
            // oberer oder unterer Rand
            if ((y1_pos < 0) | (y2_pos < 0) | (y3_pos < 0)| (y1_pos > appletsize_y) | (y2_pos > appletsize_y)|(y3_pos > appletsize_y)) {
                ysteig =ysteig*-1;
            }
            
            x1_pos+=xsteig;
            y1_pos+=ysteig;
            
            x2_pos+=xsteig;
            y2_pos+=ysteig;
            
            x3_pos+=xsteig;
            y3_pos+=ysteig;
            
            
            repaint();
            
            try {
                // Stoppen des Threads für in Klammern angegebene Millisekunden
                Thread.sleep(50);
            }
            catch (InterruptedException ex) {
                // do nothing
            }
            // Zurücksetzen der ThreadPriority auf Maximalwert
            Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        }
    }
    
    /** Update - Methode, Realisierung der Doppelpufferung zur Reduzierung des Bildschirmflackerns */
    public void update(Graphics g) {
        // Initialisierung des DoubleBuffers
        if (dbImage == null) {
            dbImage = createImage(this.getSize().width, this.getSize().height);
            dbg = dbImage.getGraphics();
        }
        
        // Bildschirm im Hintergrund löschen
        dbg.setColor(getBackground());
        dbg.fillRect(0, 0, this.getSize().width, this.getSize().height);
        
        // Auf gelöschten Hintergrund Vordergrund zeichnen
        dbg.setColor(getForeground());
        paint(dbg);
        
        // Nun fertig gezeichnetes Bild Offscreen auf dem richtigen Bildschirm anzeigen
        g.drawImage(dbImage, 0, 0, this);
    }
    
    
    public void paint(Graphics g) {
        g.setColor  (Color.red);
        //g.fillOval((int)x1_pos,(int)y1_pos, 10,10);
        g.drawRect(0,0,300,200);
        int[]a={(int)x1_pos,(int)x2_pos,(int)x3_pos};
        int[]b={(int)y1_pos,(int)y2_pos,(int)y3_pos};
        g.fillPolygon(a,b,3);
        /**
         * g.drawLine((int)x1_pos,(int)y1_pos,(int)x2_pos,(int)y2_pos);
         * g.drawLine((int)x2_pos,(int)y2_pos,(int)x3_pos,(int)y3_pos);
         * g.drawLine((int)x3_pos,(int)y3_pos,(int)x1_pos,(int)y1_pos);
         */
        repaint();
        
        
    }
    
    
}
```


so weit bin ich mit dem Code. Das Programm hab ich nur zum ausprobieren geschrieben, nur wie ich das dreieck am besten drehe, da häng ich im moment
lg murmel

_Edit von L-ectron-X: Codetags eingefügt._


----------



## Gast (18. Apr 2005)

HI, ich bins nochmal , murm3l, Hat vielleiht wer eine Ahnung wie ich ein Dreieck drehen kann?? das drehen wäre ja möglich aber dieses Dreieck fleigt kreuz und quer im Applet herum. Wenn wer idee zur lösung meines Probs hätte, dann wäre das echt nice.

lg murm3l


----------



## CyberKane (20. Apr 2005)

Wieviel bekomm ich, wenn ich das mache?


----------



## abollm (20. Apr 2005)

Gast hat gesagt.:
			
		

> HI, ich bins nochmal , murm3l, Hat vielleiht wer eine Ahnung wie ich ein Dreieck drehen kann?? das drehen wäre ja möglich aber dieses Dreieck fleigt kreuz und quer im Applet herum. Wenn wer idee zur lösung meines Probs hätte, dann wäre das echt nice.
> 
> lg murm3l



Indem du eine Methode zum Transformieren deiner Dreiecke implementierst.

Da ein Dreieck - wie der Name schon sagt - drei Punkte zur Beschreibung haben muss, übergibst du der Methode jeweils nacheinander die drei Punkte und transformierst sie.

Dabei übergibst du u.a. auch den Winkel.

Also mal so als Anregung (ist für eine 3D-Simulation, also nicht stumpf kopieren!):


```
// Führt eine Rotation, Skalierung und Translation des Punktes aus.

  public void transform(double ax, double ay, double az, double m, double dx, double dy, double dz) {

    double x, y, z, c, s;

    // Um die X-Achse rot.

    x = this.xo; y = this.yo; z = this.zo;
    c = Math.cos(ax);
    s = Math.sin(ax);
    this.xt = x;
    this.yt = y * c - z * s;
    this.zt = y * s + z * c;

    // Um die Y-Achse rot.

    x = this.xt; y = this.yt; z = this.zt;
    c = Math.cos(ay);
    s = Math.sin(ay);
    this.xt = x * c - z * s;
    this.yt = y;
    this.zt = x * s + z * c;

    // Um die Z-Achse rot.

    x = this.xt; y = this.yt; z = this.zt;
    c = Math.cos(az);
    s = Math.sin(az);
    this.xt = x * c - y * s;
    this.yt = x * s + y * c;
    this.zt = z;

    // Skalieren

    this.xt *= m; this.yt *= m; this.zt *= m;

    // Translation durchführen.

    this.xt += dx; this.yt += dy; this.zt += dz;
  }
```

Hth


----------

