# Schuss mit Mausklick



## ivo1994 (20. Jan 2010)

Hallo zusammen
Ich möchte Schüsse programmieren. Bis jetzt habe ich einen Punkt, welchen ich bewegen kann und nun möchte ich einen Schuss programmieren, welcher in die richtung des Mausklicks fliegt. Habt ihr Ideen. Hab keine Ahnung wie ich beginnen soll.


```
public class spieler extends Applet implements Runnable
{
                // Initialisierung der Variablen
                int x_pos = 30;                                 // x - Position des Balles
                int y_pos = 100;                               // y - Position des Balles
                int x_speed = 0;                              // Geschwindigkeit des Balles in x - Richtung
                int radius = 10;                  // Radius des Balles
                int appletsize_x = 900; // Größe des Applets in x - Richtung
                int appletsize_y = 900;  // Größe des Applets in y - Richtung

                // Variablen für die Doppelpufferung
                private Image dbImage;
                private Graphics dbg;

                public void init()
                {
                               setBackground (Color.black);
                               setSize(900, 900);
                }				

                public void start ()
                {
                               // Schaffen eines neuen Threads, in dem das Spiel läuft
                               Thread th = new Thread (this);
                               setSize(1200, 800);
                               // Starten des Threads
                               th.start ();
                }
            
                              

                /* Diese Methode fängt das Ereigniss auf, das beim Drücken einer Keyboardtaste entsteht.
                Die Tasten Cursor links, rechts und die Space Taste haben dabei eine bestimmte Bedeutung.
                Wird eine andere Taste gedrückt, so wird ihr Integerwert in die Standardausgabe geschrieben. */
                public boolean keyDown (Event e, int key)
                {
                
                               
                               // obere Cursortaste
                               if (key == 119)
                               {
                                               // Ball bewegt sich dann nach oben
                                               y_pos = y_pos - 5;
                               }
                               // untere Cursortaste
                               else if (key == 115)
                               {
                                               // Ball bewegt sich dann nach unten
                                               y_pos = y_pos +5;
                               }
                               // linke Cursortaste
                               else if (key == 97)
                               {
                                               // Ball bewegt sich dann nach links
                                               x_pos = x_pos -5;
                               }
                               // rechte Cursortaste
                               else if (key == 100)
                               {
                                               // Ball bewegt sich dann nach rechts
                                               x_pos =x_pos + 5;
                               }
                               // SpaceBar hat Wert 32
                               else if (key == 32)
                               {
                                             Shot.main(null);
                                     
                               }
                               else
                               {
                                               // Ausgabe von gedrüktem Key und Zahlenwert an die Standardausgabe
                                               System.out.println ("Charakter: " + (char)key + " Integer Value: " + key);
                               }

                               return true;
                }
                public Shot generateShot(){
              	  Shot shot=new Shot(x_pos, y_pos);
              	  return shot;
                }
               
                
                
                
                public void run ()
               
                {
                               // Erniedrigen der ThreadPriority um zeichnen zu erleichtern
                               Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

                               // Solange true ist läuft der Thread weiter
                               while (true)
                               {
                                               // Wenn der Ball den rechten Rand berührt, dann prallt er ab
                                               if (x_pos > appletsize_x - radius)
                                               {
                                                               // Ändern der Richtung des Balles
                                                               x_speed = +0;
                                               }
                                               // Ball brührt linken Rand und prallt ab
                                               else if (x_pos < radius)
                                               {
                                                               // Ändern der Richtung des Balles
                                                               x_speed =  -0;
                                               }

                                               // Verändern der x- Koordinate
                                               x_pos += x_speed;

                                               // Neuzeichnen des Applets
                                               repaint();

                                               try
                                               {
                                                               // Stoppen des Threads für in Klammern angegebene Millisekunden
                                                               Thread.sleep (20);
                                               }
                                               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 (x_pos - radius, y_pos - radius, 2 * radius, 2 * radius);
                }


                public class shot
                {

                      // Variablen
                      private int x_pos;
                      private int y_pos;

                      // Schussradius
                      private final int radius = 3;

                      // Konstruktor
                      public shot(int x, int y)
                      {
                            x_pos = x;
                            y_pos = y;
                      }

                      // liefert die y - Position zurück
                      public int getYPos()
                      {
                            return y_pos;
                      }
                      public int getXPos()
                      {
                            return x_pos;
                      }

                      // bewegt den Schuss in y - Richtung
                      public void moveShot(int speed)
                      {
                            y_pos += speed;
                      
                            x_pos += speed;
                      }

                      // zeichnet den Schuss
                      public void drawShot(Graphics g)
                      {
                            g.setColor(Color.yellow);
                            g.fillOval(x_pos, y_pos, radius, radius);
                      }
```


----------



## Marco13 (20. Jan 2010)

Ich glaube nicht, dass du "Schüsse Programmieren" willst. Ich vermute eher, dass du ein Programm (irgendein Spiel (hoffentlich  )) schreiben willst, wo _unter anderem_ Schüsse gezeichnet werden. 

Du solltest dir also ERST über eine vernünftige Struktur für dein Spiel Gedanken machen. Die Liste der Variablen oben in der Applet-Klasse sieht schon verdächtig aus :autsch:

Abgesehen davon: Applet ist AWT, und das ist eigentlich veraltet - stattdessen solltest du vielleicht Swing verwenden - da braucht man sich auch um DoubleBuffering keine Gedanken mehr zu machen.

Und von welcher Seite auch immer du hast, dass man die "keyDown"-Methode verwendet: Besuch' die Seite nicht wieder ... 

Schau dir vielleicht mal http://www.java-forum.org/buecher-tutorials-links/14545-tutorials-mitgliedern.html#post383565 an - das ist ein gut strukturierter Einstieg.


----------



## Steev (20. Jan 2010)

Das kannst du relativ einfach mithilfe der Winkelsätze im Dreieck lösen.
Zwei Punkte hast du ja schon: (1. Punkt = Abschussposition, 2. Punkt = Mausposition).
Wenn du den Winkel hast, dann must du nur noch den Winkel auf die Geschwindigkeiten anwenden und schon geht der Schuss in die richtige Richtung.


----------



## Quaxli (20. Jan 2010)

Ein paar Bedenken hinsichtlich des Spielflusses habe ich bei dem Steuerkonzept. Wenn schon Maus und Tastatur gleichzeitig, würde ich die Steuerung wei bei einem EgoShooter anlegen: Statt Cursor-Tasten lieber W,A,S,D und mit der rechten Hand die Maus.


----------

