# Ping Pong Spiel



## Reality (30. Jul 2004)

Hi,
bei meinem "Ping Pong-Spiel" funktioniert die Barriere nicht besonders gut.







Wie ihr seht, geht der Ball durch den unteren Balkenrand durch. Anders umgekehrt. Wenn der Balken ziemlich weit unten ist, prallt der Ball trotzdem ab, obwohl dazwischen ca 10-15 Pixel frei sind.

Hier der Quellcode:


```
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.JOptionPane;

public class BallDemo extends Applet implements Runnable, KeyListener{

boolean stop = false;

int x_pos = -20;
int y_pos = 100;

int x_pos2 = 5;
int y_pos2 = 150;

int radius = 40;
int x_speed = 2;

  public void init()
  {
    setBackground (Color.blue);
    addKeyListener(this);
  }

  public void start(){
    Thread th = new Thread (this);
    th.start ();
  }

  /*public void update(Graphics g){
    paint(g);
  }*/

  public void run ()
  {
     Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

     while (true)
     {
           // Neuzeichnen des Applets
           repaint();

           /*if(x_pos == 418)
             x_pos = -20;*/ //Beam me up Scotty

           if(x_pos < 0 && stop){
             JOptionPane.showMessageDialog(this, "Verloren!");
             break;
           }
         
            /* 8 ist die Hälfte von der Breite des Balkens. 20 ist die Hälfte des radius (was Höhe und Breite entspricht). 
            42 ist die Hälfte von der Höhe des Balkens*/

           else if(x_pos <= x_pos2 + 8 && y_pos - 20 <= y_pos2 + 42 && y_pos + 20 >= y_pos2 - 42){
             x_speed = 2;
           }

           else if(x_pos == radius && !stop){
             x_speed = 2;
             stop = true;
           }

           else if(x_pos == 400 - radius)
             x_speed = -2;


           x_pos += x_speed;

           try
           {
             Thread.sleep (20);
           }
           catch (InterruptedException ex)
           {
                 // do nothing
           }

           // Zurücksetzen der ThreadPriority auf Maximalwert
           Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
     }

   }

   public void paint (Graphics g)
   {

      // Setzten der Zeichenfarbe auf Rot
      g.setColor (Color.red);

      // Zeichen eines gefüllten Kreises
      g.fillOval (x_pos, y_pos, radius, radius);
      g.fillRect(x_pos2, y_pos2, 16, 84);

    }

    public void keyPressed(KeyEvent taste){
      int i = taste.getKeyCode();

      switch(i){
        case KeyEvent.VK_DOWN:
          y_pos2 += 5;
          break;

        case KeyEvent.VK_UP:
          y_pos2 -= 5;
          break;
      }
    }

    public void keyReleased(KeyEvent e){
    }

    public void keyTyped(KeyEvent e){
    }
}
```

Liebe Grüße
Reality


----------



## pogo (30. Jul 2004)

bei mir auf m rechner kann der ball an der barriere vorbeigehen und kommt trotzdem wieder zurück


----------



## Reality (30. Jul 2004)

Hä? ???:L 
Also wenn der Ball so ziemlich auf die Mitte des Balkens prallt, dann prallt er zurück. Ansonsten wenn der Ball durchkommt, kommt eine Meldung, dass man verloren hat.

Liebe Grüße
Reality


----------



## pogo (30. Jul 2004)

bei mir kann er aber ncoh neben dem balken zurückprallen


----------



## Reality (30. Jul 2004)

Ja, das ist ja das Problem. Die Barrieren stimmen einfach nicht. Wenn der Balken unten ist und bei der Y-Achse sind etwa 10 Pixel frei, dann prallt der Ball trotzdem ab.
Anders umgekehrt. Wenn der Balken oben ist und und der Ball bei den letzten ~ 15 Pixel des Balkens abprallen sollte, dann geht er durch.

Du kannst übrigens den Balken mit den Pfeiltasten steuern, wenn du auf das Applet klickst und dann die Pfeiltasten benutzt.

Liebe Grüße
Reality


----------



## Isaac (30. Jul 2004)

Ich hab das mal  ein bischen umgeschireben und hoffentlich leserlicher gemacht, aber so gehts nun 

Edit: So wies nun ist reagiert das Panel und damit die Methode "isInRange" auf den Ball Mittelpunkt


```
import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JOptionPane;

public class BallDemo extends Applet implements Runnable, KeyListener
{

    boolean stop                = false;
    int     ballYposition       = 100;
    int     panel_Xposition     = 5;
    int     panelYposition      = 150;
    int     ballRadius          = 40;
    int     ballSpeed           = 2;
    int     panelWidth          = 16;
    int     panelHeight         = 84;
    int     ballXposition       = panelWidth + 2; //die +2 sind nur damit man am Anfang nicht gleich verloren hat
    
    public void init()
    {
        setBackground(Color.blue);
        addKeyListener(this);
    }

    public void start()
    {
        Thread th = new Thread(this);
        th.start();
    }

    /*
     * public void update(Graphics g){ paint(g); }
     */

    public void run()
    {
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        while (true)
        {
            // Neuzeichnen des Applets
            repaint();

            //ist das panel wo der Ball ist, wenn der Ball beim Spieler ist?
            if(ballXposition <= panelWidth)
            {
                //diff ist zur bestimmung ob ball im Bereich des panel ist. panel z.b. von Y=100 bis Y=184
                if(isInRange(ballYposition))
                {
                    ballSpeed = 2;
                }
                else
                {
                    stop = true;
                }
            }
                
            /*
             * if(x_pos == 418) x_pos = -20;
             *///Beam me up Scotty
            if (stop)
            {
                JOptionPane.showMessageDialog(this, "Verloren!");
                break;
            }

            //ist der ball am ende angekommen?  
            if (ballXposition >= 400 - ballRadius)
            {
                ballSpeed = -2;
            }

            ballXposition += ballSpeed;

            try
            {
                Thread.sleep(20);
            }
            catch (InterruptedException ex)
            {
                // do nothing
            }

            // Zurücksetzen der ThreadPriority auf Maximalwert
            Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        }

    }
    
    private boolean isInRange(int yPosition)
    {
        boolean bInRange;
        //weil für den Ball ein einschliessendes rechteck gilt ist die yPosition immer oben rechts
        //ausserhalb des Balls, das gleichen wir nun aus
        int trueYPosition = yPosition + ballRadius/2;
        
        if(trueYPosition > panelYposition && trueYPosition < panelYposition + panelHeight - 1)
        {
            bInRange = true;
        }
        else
        {
            bInRange = false;
        }
        return bInRange;
    }

    public void paint(Graphics g)
    {

        // Setzten der Zeichenfarbe auf Rot
        g.setColor(Color.red);

        // Zeichen eines gefüllten Kreises
        g.fillOval(ballXposition, ballYposition, ballRadius, ballRadius);
        g.fillRect(panel_Xposition, panelYposition, panelWidth, panelHeight);

    }

    public void keyPressed(KeyEvent taste)
    {
        int i = taste.getKeyCode();

        switch (i)
        {
        case KeyEvent.VK_DOWN:
            panelYposition += 5;
            break;

        case KeyEvent.VK_UP:
            panelYposition -= 5;
            break;
        }
    }

    public void keyReleased(KeyEvent e)
    {
    }

    public void keyTyped(KeyEvent e)
    {
    }
}
```


----------



## Reality (30. Jul 2004)

Hallo Meister 
Dein Spiel ist genauso buggy wie meins. D.h., das mein Problem bestehen bleibt mit der Barriere.






Liebe Grüße
Reality


----------



## Isaac (30. Jul 2004)

Nein, ich sagte das Panel regiert auf den Ball Mittelpunkt oder die Mittellinie. Wie du auf dem Screenshot siehst ist die Mittellinie unter dem Panel. Wenn du das weg haben willst must du die isInRange Methode entsprechend modifizieren. Ich dachte aber das du anhand des Auftreffpunktes später eintritts und austrittswinkel berechnen willst, deshalb hab ich das erstmal so gemacht.

Wenn du willst kann ich dir die isInRange auch noch mal so modifizieren das sie auf den gesammten Ball reagiert. Das ist ein + und ein - hier. Aber dann sieht es genauso bescheuert aus weil dann auf die aussenkanten reagiert wird. Sprich, wenn auch nur ein fitzel des Balls noch auf dem Panel ist, wird der Ball zurück gestossen.


Du must nun die isInRange Methode aufboren.


----------



## Reality (30. Jul 2004)

Am liebsten würde ich gerne wissen, was bei mir falsch ist, denn mit meinem Code komme ich noch immer am Besten zu Recht. Es sollte schon auf den kompletten Ball reagieren und nicht nur auf einen Teil.

Liebe Grüße
Reality


----------



## Isaac (30. Jul 2004)

nuja ich hab ne menge gelöscht weils unnötig war. Aber ich denke der grösste Fehler war das du ball Y nicht als oben links benutzt hast. Die koordinaten des Balls sind x/y oben links. Aber genau kann ich dir das nicht sagen da ich alles gelöscht habe was unnötig war. Man muss nicht alle nase lang prüfen ob Schläger und Ball da sind, das ist erst nötig wenn der Ball beim Schläger ist...

Nuja, ich blickte durch dein Code nicht wirklich durch deshalb dieses kleine rewriting, so viel hab ich ja garnicht verändert ) jedenfalls weniger als ich gemacht hätte wenn das mein Code wäre *g*


----------



## Reality (30. Jul 2004)

Hi,


			
				Isaac hat gesagt.:
			
		

> Aber ich denke der grösste Fehler war das du ball Y nicht als oben links benutzt hast. Die koordinaten des Balls sind x/y oben links.


versteh` leider nicht was du meinst. ???:L Dein Programm hat genau den gleichen Fehler wie meins. Wenn du die Barrieren richtig hinkriegen kannst, dann würde ich gerne wissen wie.

Liebe Grüße
Reality


----------



## Isaac (30. Jul 2004)

Oki:


Der Ball ist für das Programm ein Viereck. Oben links die Ecke ist x und y.+
Daraus folgt das wenn man des Balles x und y koordinaten abfragt  ausserhalb des Balles ist. Stell dir mal ein Viereck um einen Ball vor, die Ecke oben links des Vierecks sind zwangsläufig ausserhalb des Balls. 

Das Programm, das von mir modifizierte, reduziert nun die Y Koordinate des Balls um die hälfte des Radius. Wenn man sich nun wieder das umschliessende Viereck vorstellt ist das genau in der Mitte des Balls (horizontal). Das Programm prüft nun ob diese Koordinate mit dem des Panel übereinstimmt...


Was hat dein Programm gemacht:

Ich mal dir nen Bild, anders kann man das schlcht erklären.


----------



## Reality (30. Jul 2004)

Achso, ja. Das mein Programm das als Quadrat absieht ist mir auch aufgefallen, aber das war nicht mein Problem.
Weisst du überhaupt was mein Problem ist?

Liebe Grüße
Reality


----------



## Isaac (31. Jul 2004)

Nachdem ich dein Programm modifiziert habe eigentlich nicht mehr. Das modifizierte Programm funktioniert für die Ball Mittellinie oben und unten. Dein Programm hat die Tatsache das posx2 eigentlich oben links beim ball ist vollkommen ignoriert weshalb es auch nicht funkioniert hat.


----------



## Isaac (31. Jul 2004)

Vieleicht macht die linie klarer was ich meine.



```
import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JOptionPane;

public class BallDemo extends Applet implements Runnable, KeyListener
{

    boolean stop                = false;
    int     ballYposition       = 100;
    int     panel_Xposition     = 5;
    int     panelYposition      = 150;
    int     ballRadius          = 40;
    int     ballSpeed           = 2;
    int     panelWidth          = 16;
    int     panelHeight         = 84;
    int     ballXposition       = panelWidth + 2; //die +2 sind nur damit man am Anfang nicht gleich verloren hat
    
    public void init()
    {
        setBackground(Color.blue);
        addKeyListener(this);
    }

    public void start()
    {
        Thread th = new Thread(this);
        th.start();
    }

    /*
     * public void update(Graphics g){ paint(g); }
     */

    public void run()
    {
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        while (true)
        {
            // Neuzeichnen des Applets
            repaint();

            //ist das panel wo der Ball ist, wenn der Ball beim Spieler ist?
            if(ballXposition <= panelWidth)
            {
                //diff ist zur bestimmung ob ball im Bereich des panel ist. panel z.b. von Y=100 bis Y=184
                if(isInRange(ballYposition))
                {
                    ballSpeed = 2;
                }
                else
                {
                    stop = true;
                }
            }
                
            /*
             * if(x_pos == 418) x_pos = -20;
             *///Beam me up Scotty
            if (stop)
            {
                JOptionPane.showMessageDialog(this, "Verloren!");
                break;
            }

            //ist der ball am ende angekommen?  
            if (ballXposition >= 400 - ballRadius)
            {
                ballSpeed = -2;
            }

            ballXposition += ballSpeed;

            try
            {
                Thread.sleep(20);
            }
            catch (InterruptedException ex)
            {
                // do nothing
            }

            // Zurücksetzen der ThreadPriority auf Maximalwert
            Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        }

    }
    
    private boolean isInRange(int yPosition)
    {
        boolean bInRange;
        //weil für den Ball ein einschliessendes rechteck gilt ist die yPosition immer oben rechts
        //ausserhalb des Balls, das gleichen wir nun aus
        int trueYPosition = yPosition + ballRadius/2;
        
        if(trueYPosition > panelYposition && trueYPosition < panelYposition + panelHeight - 1)
        {
            bInRange = true;
        }
        else
        {
            bInRange = false;
        }
        return bInRange;
    }

    public void paint(Graphics g)
    {

        // Setzten der Zeichenfarbe auf Rot
        g.setColor(Color.red);

        // Zeichen eines gefüllten Kreises
        g.fillOval(ballXposition, ballYposition, ballRadius, ballRadius);
        g.fillRect(panel_Xposition, panelYposition, panelWidth, panelHeight);
        g.drawLine(0, ballYposition + ballRadius/2, 400, ballYposition + ballRadius/2);

    }

    public void keyPressed(KeyEvent taste)
    {
        int i = taste.getKeyCode();

        switch (i)
        {
        case KeyEvent.VK_DOWN:
            panelYposition += 5;
            break;

        case KeyEvent.VK_UP:
            panelYposition -= 5;
            break;
        }
    }

    public void keyReleased(KeyEvent e)
    {
    }

    public void keyTyped(KeyEvent e)
    {
    }
}
```


----------



## Reality (31. Jul 2004)

Hi Isaac,
deine Barriere stimmt leider immernoch nicht.
Jetzt weiss ich warum das ganze nicht ging. Ich habe gedacht, dass y_pos jeweils in der Mitte des jeweiligen Graphens ist. Aber du hast mich mit g.draw() drauf gebracht, wie ich die wahre y-Position ermitteln kann und so habe ich den Fehler behoben.

Das ist der richtige Code:


```
else if(x_pos <= x_pos2 + 8 && y_pos <= y_pos2 + 84 && y_pos + 40 >= y_pos2){
             x_speed = 2;
           }
```

Jetzt klappts auch mit den Barrieren. 

Liebe Grüße
Reality


----------



## Isaac (31. Jul 2004)

nu gib den Variablen noch sprechende Namen und dann versteht vieleicht auch einer was du da machst.  :bae:


----------



## Roar (31. Jul 2004)

Reality hat gesagt.:
			
		

> ```
> else if(x_pos <= x_pos2 + 8 && y_pos <= y_pos2 + 84 && y_pos + 40 >= y_pos2){
> x_speed = 2;
> }
> ```



is doch ok  ne neue methode von obfuscating  :lol:

*edit: * kein catering *g*   obfuscating soll es heissen  :roll:


----------



## Reality (31. Jul 2004)

Isaac hat gesagt.:
			
		

> nu gib den Variablen noch sprechende Namen und dann versteht vieleicht auch einer was du da machst.  :bae:



Ich habe noch nen kleinen Fehler gefunden. Die 8 in der else if-Anweisung muss durch eine 16 ersetzt werden. Das hatte den Effekt, dass der Ball ein bisschen in den Balken reingedrückt wurde.

Die 16 ist also die Breite des Balkens. Die 40 ist die Länge und Breite des Kreises. Die 84 ist die Länge des Balkens.
Alles andere musst du dir bildlich vorstellen, damit du das nachvollziehen kannst.

@roar: obfuscatering? ???:L  Google übersetzt mir das nicht.

Liebe Grüße
Reality


----------



## TheHippo (3. Aug 2004)

morgen ihr...
jez muss ich nochma dumm zum thema labber (eigentlich is es ja was anderes)... un zwar habsch dank euch nun endlich ne möglichkeit gefunden irgendwie sinnvoll die tastatur zu überwachen... tnx
übrigens: 

ob·fus·cate [] v/t fig 
1. verwirren
2. vernebeln

© Langenscheidt KG, Berlin und München


----------



## L-ectron-X (3. Aug 2004)

@Reality: Es gibt für Java so genannte Obfuscator, mit denen es möglich ist, den Quellcode so zu gestalten, dass er bei Dekompilierung nahe zu unleserlich bzw. schlecht nachvollziehbar ist. Damit soll einem Dekompilierer die Möglichkeit des Lesens fremden Quellcodes erschwert werden.

Das Wort welches Roar benutzte ist interessant. Nur weiß ich nicht, ob er es versehentlich so geschrieben hat.
Wenn man es auseinander nimmt: obfus|catering
- obfus = verfinstern, vernebeln, verwirren, trübend
- catering = Verpflegung, Bewirtung, Bankettservice

Das klingt für mich nach einer schlechten Party. :wink:


----------



## Reality (3. Aug 2004)

Hi L-ectron-X,
klingt interessant das obfuscatering. 

Ich bin übrigens mit dem Spiel fertig bzw. es funktioniert.
Wer es testen mag, kann es kompilieren.


```
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.JOptionPane;
import java.util.*;

public class PingPong extends Applet implements Runnable, KeyListener{
Random r = new Random();

// Definition zweier Instanzvariablen für die Doppelpufferung im Kopf des Programmes
private Image dbImage;
private Graphics dbg;

boolean stop = false;
boolean play = true;
boolean level1 = true;

int x_pos = -20;
int y_pos = r.nextInt(260);

int x_pos2 = 5;
int y_pos2 = 150;

int x_pos3 = 380;
int y_pos3 = 100;

int radius = 40;
int x_speed = 2;

int forward = 2;
int reverse = -2;

int steigung = 2;
int points = 0;

int level = 1;

int kiStep = 2;
int kiSight = 200;

  public void init()
  {
    setBackground (Color.blue);
    addKeyListener(this);
  }

  public void start(){
    Thread th = new Thread (this);
    th.start ();
  }

  void ki(){

    if(x_pos >= kiSight && x_speed > 0){

      //if(y_pos + 40 >= y_pos3 && y_pos <= y_pos + 84){}

      if(y_pos > y_pos3){
        if(y_pos3 + 84 >= 300){}

        else
          y_pos3 += kiStep;
      }

      else if(y_pos < y_pos3){
        if(y_pos3 <= 0){}

        else
          y_pos3 -= kiStep;
      }
    }
  }


  public void run ()
  {
     Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

     while (play)
     {
       if(points >= 15 && level1){
         forward = 4;
         reverse = -4;
       }

           ki();

           /*if(x_pos == 418)
             x_pos = -20;*/ //Beam me up Scotty

           if(x_pos < 0 && stop){
             JOptionPane.showMessageDialog(this, "Du hast verloren!\nPunkte: " + points);
             break;
           }

           else if(x_pos <= x_pos2 + 5 && y_pos <= y_pos2 + 84 && y_pos + 40 >= y_pos2){
                   x_speed = forward;
                 }

           else if(x_pos >= radius && !stop){
             stop = true;
           }

           /*else if(x_pos >= 400 - radius){
             x_speed = reverse;
             points += 5;
           }*/ //Falls man alleine spielt; ohne Gegner- also gegen die Wand.

          win();

          if(x_pos >= x_pos3 -35 && y_pos + 40 >= y_pos3 && y_pos <= y_pos3 + 84){
            x_speed = reverse;
            points += 5;
          }


          switch(y_pos)
          {
              case 261:
              case 260:
                steigung = -2;
                break;

              case 0:
              case -1:
                steigung = 2;
                break;
          }

           x_pos += x_speed;
           y_pos += steigung;

           // Neuzeichnen des Applets
           repaint();

           try
           {

             Thread.sleep (20);
           }
           catch (InterruptedException ex)
           {
                 // do nothing
           }

           // Zurücksetzen der ThreadPriority auf Maximalwert
           Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
     }

   }

   public void paint (Graphics g)
   {

      // Setzten der Zeichenfarbe auf Rot
      g.setColor (Color.red);

      // Zeichen eines gefüllten Kreises
      g.fillOval (x_pos, y_pos, radius, radius);
      g.fillRect(x_pos2, y_pos2, 15, 84);
      g.fillRect(x_pos3, y_pos3, 15, 84);
    }

    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 keyPressed(KeyEvent taste){
      int i = taste.getKeyCode();

      switch(i){
        case KeyEvent.VK_DOWN:
          y_pos2 += 9;
          break;

        case KeyEvent.VK_UP:
          y_pos2 -= 9;
          break;
      }
    }

    public void keyReleased(KeyEvent e){
    }

    public void keyTyped(KeyEvent e){
    }

    void win(){
      if(x_pos > 400 - 40){
        play = false;

      switch(++level){
       case 2:
       JOptionPane.showMessageDialog(this, "Das war ja noch leicht! Weiter geht´s mit Level 2");

        kiStep = 4;
        x_pos = 0;
        y_pos = r.nextInt(260);
        stop = false;
        forward = 8;
        reverse = -8;
        level1 = false;
        kiSight = 194;
        play = true;
        break;

        case 3:
          JOptionPane.showMessageDialog(this, "Nicht schlecht! Auf geht´s mit Level 3");

          kiStep = 5;
          x_pos = 0;
          y_pos = r.nextInt(260);
          stop = false;
          points = 30;
          kiSight = 189;
          forward = 10;
          reverse = -10;
          play = true;
          break;

        case 4:
          JOptionPane.showMessageDialog(this, "Super! Auf geht´s zum Finale mit Level 4");

          x_pos = 0;
          y_pos = r.nextInt(260);
          kiStep = 6;
          stop = false;
          kiSight = 204;
          forward = 10;
          reverse = -10;
          play = true;
          break;

        case 5:
          JOptionPane.showMessageDialog(this,
          "Gratulation! Du hast gewonnen!\n Punktestand: " + points);
        break;
      }

      }

    }
}
```

Der Quellcode ist nicht sehr verständlich. Das liegt daran, dass ich bei billigen Programmen keinen Wert auf Lesbarkeit lege.

EDIT: Quellcode nochmal überarbeitet.

Liebe Grüße
Reality


----------



## Illuvatar (3. Aug 2004)

Schaut ja gut aus.
Aber du solltest vielleich noch ne Abfrage machen, dass der Schläger nicht aus dem Bildschirm rausgeht, jedenfalls ist das bei mir möglich.


----------



## Reality (3. Aug 2004)

Hi,
die Abfrage habe ich nur bei der "KI" gemacht. Ich dachte noch mehr Abfragen würde das Spiel noch mehr zum Ruckeln bringen. Wie läuft es bei dir?

EDIT: Wer es übrigens schwerer haben will, der sollte kiSight (je kleiner desto schwieriger) und kiStep (je größer desto schwieriger) bei der If-Abfrage von Level 4 editieren.

Liebe Grüße
Reality


----------



## L-ectron-X (3. Aug 2004)

Ist bei mir auch so.
Ich habe auch Probleme den "Schläger" auf bzw. abwärts zu bewegen. Dazu benutze die Cursortasten.
Machmal reagiert der "Schläger" einfach nicht.
Gegen das Flackern kannst Du noch etwas machen. Dazu kannst Du die Bilder in einem Offscreen-Image vorbereiten und auf einmal auf die Oberfläche kopieren. (Double Buffering).
Und noch eine kleine, aber nicht zu unterschätzende Sache: Du verwendest java.util.Random#nextInt() und ein JOptionPane. Das sind Dinge, die nicht mit den alten Java-VM kompatibel sind.
Wenn sie nicht unbedingt benötigt werden und Du das Spiel mal im Internet veröffentlichen willst, solltest Du darauf achten. Leider ist es noch so, dass der IE in der "Grundausstattung" die MS-VM mitbringt, sich viele Benutzer darum keine Gedanken machen und der IE daher mit diesen Dingen nicht klar kommt.


----------



## Reality (3. Aug 2004)

L-ectron-X hat gesagt.:
			
		

> Ist bei mir auch so


Bei mir ruckelt es nur am Browser ein bisschen, wenn ich es mit dem Borland JBuilder starte, läuft es flüssig. Nur manchmal stockt es für ein Bruchteil einer Sekunde.
Was für ein System hast du?


> Ich habe auch Probleme den "Schläger" auf bzw. abwärts zu bewegen. Dazu benutze die Cursortasten.
> Machmal reagiert der "Schläger" einfach nicht.


Komisch, vielleicht hast du einen zu langsamen Rechner. Ich weiss einfach nicht, wie ich das ressourcenschonender programmieren könnte.


> Gegen das Flackern kannst Du noch etwas machen. Dazu kannst Du die Bilder in einem Offscreen-Image vorbereiten und auf einmal auf die Oberfläche kopieren. (Double Buffering).


Von der Doppelpufferung habe ich auch schon gehört, mich aber noch nicht damit befasst.


> Und noch eine kleine, aber nicht zu unterschätzende Sache: Du verwendest java.util.Random#nextInt() und ein JOptionPane. Das sind Dinge, die nicht mit den alten Java-VM kompatibel sind.
> Wenn sie nicht unbedingt benötigt werden und Du das Spiel mal im Internet veröffentlichen willst, solltest Du darauf achten. Leider ist es noch so, dass der IE in der "Grundausstattung" die MS-VM mitbringt, sich viele Benutzer darum keine Gedanken machen und der IE daher mit diesen Dingen nicht klar kommt.


Find das Spiel eigentlich zu doof/billig, um es für die Verallgemeinheit zu veröffentlichen. :lol: 

Liebe Grüße
Reality

EDIT: Wenn man bei den Level-If-Abfragen durch switch/case ersetzt, geht das vielleicht etwas schneller.


----------



## L-ectron-X (3. Aug 2004)

> Was für ein System hast du?


WinXP


> Komisch, vielleicht hast du einen zu langsamen Rechner.


Nun ja, ich kann zumindest moderne 3D-Games mit meiner Kiste spielen.
Athlon 2000+
512 MB DDR-Ram
ATI 9000 Grafikkarte.
Wäre Mist, wenn ich für Dein Spiel nun aufrüsten müsste. :wink: 

Ich hatte mal ein ähnliches Problem. Ich hatte den MouseMotionListener an einem Applet registriert. Und immer, wenn die Maus über das Applet bewegt wurde, sollte eine Abfrage gemacht werden und die CPU-Last ging gegen 100%. Die Maus stotterte über das Applet.
Im Appletviewer war das kein Problem, im Browser aber schon.

Wahrscheinlich hast Du hier ein ähnliches Problem.

Ich habe es dann so gemacht, dass ich in der mouseMoved()-Methode noch ein paar if-Bedingungen gesetzt habe, so dass wirklich nur noch dann eine Abfrage gemacht wurde, wenn das auch nötig war.


> Find das Spiel eigentlich zu doof/billig, um es für die Verallgemeinheit zu veröffentlichen.


Musst Du ja auch nicht. Es ging ja nur ums Prinzip.


----------



## newbie1221 (4. Aug 2004)

Vielleicht solltet ihr euch mal nen 2D Java Guide anschauen, nur so als tipp.

Oder bringt dat nix


----------



## Reality (4. Aug 2004)

newbie1221 hat gesagt.:
			
		

> Vielleicht solltet ihr euch mal nen 2D Java Guide anschauen, nur so als tipp.
> 
> Oder bringt dat nix


Wieso? Weil das Spiel ruckelt?
Ich habe mein Beitrag oben editiert wo ich den Quellcode gepostet habe. Ich habe jetzt die Doppelpufferung eingebaut und das Spiel läuft bei mir jetzt absolut flüssig im Browser.

Liebe Grüße
Reality


----------

