Probleme beim Ausführen @ tutorials.de: Tutorials, Forum & Hilfe

Baopi · 20.10.10 20:25

Hallo,

ich hab ein kleines Pong Spiel programmiert allerdings kann man dieses Spiel nicht auf jedem PC vernünftig ausführen. Dieses Spiel war ein Schulprojekt von mir und in dieser Schule hatten wir Rechner mit der selben Hardware und Software alles zu 100% gleich doch mein Spiel lief nur an meinem Platz und auf dem Rechner eines Mitschülers Zuhause an sonst keinem einzigen Platz, bei den Lehrern Zuhause und bei mir lief das Spiel auch nicht und ich weiß nicht woran das liegen kann. An der Version von Java kann es nicht liegen, da die Rechner in der Schule alle auf dem gleichen Stand sind und Fehlermeldungen werden auch nicht ausgegeben. Das einzigste Problem ist, dass das Spiel außer auf den 2 genannten Rechnern hängen bleibt und man auf dem Formular nichts mehr sieht.

z-mon · 20.10.10 21:00

Hallo Baopi,

wie startest du denn das Spiel? Direkt aus der Entwicklungsumgebung, von der Konsole oder hast du dir ein .jar File erstellt?

Schöne Grüße

SPiKEe · 20.10.10 21:02

ich kennen dieses problem ...
das passiert zur zeit aber nicht nur in apps sondern auch in applets
ich bin bei einem bekannten chat-system angemeldet welches ebenfalls java verwendet ...
auf meinem rechner ist das Java7-EA-b76 installiert ...
zusätzlich noch Java6 Update20
auf einem virtuellen rechner habe ich nur Java5.0 Update13 drauf ...
alle drei versionen lösen bei diesem chat-system einen änlichen fehler aus ...
an einem gewissen punkt bleibt nicht nur die GUI hängen sondern die gesamte VM und manchmal sogar mein browser gleich mit *mit verschiedenen kombinationen probiert*

jedoch kann ich alles andere ohne verzögerungen / abstürze ausführen ...
ich vermute daher das es an entweder an einem unsauberen programmier-stil liegt der sich halt gerne in DEADLOCKS verfängt oder probleme in der VM selbst welche durch ungewönliche konstrukte und innere abläufe hervorgerufen werden ...

ich denke da wir zwei nicht die einzigen sind die in letzter zeit ein solches verhalten von java mitbekommen haben *und das mit unterschiedlichen versionen und vor allem völlig von einander unabhängigen code* werden das wohl keine einzelfälle sein ...
wird wohl n rätzel bleiben was hier vor sich geht ...
wobei ich auch über eine klärung ganz froh wäre

Baopi · 21.10.10 00:49

ich starte es direkt aus der Entwicklungsumgebung
danke für deine Antwort Z-mon

Baopi · 21.10.10 00:50

Danke SPiKEe für diese Ausführliche Erklärung

***zeja*** · 21.10.10 11:25

Ein Chat verwendet auf jeden Fall Threads. Verwendet dein Pong Spiel auch Threads? Dann kann es durchaus sein, dass es durch unsaubere Programmierung zu solche Fehlern kommt, da sich die VM in den letzten Java-Versionen innerhalb der Spezifikation etwas anders verhält als zuvor. Threads werden z.B. häufiger mal zwischendurch aufgeweckt (spurious wakeup) was zwar immer schon erlaubt war, aber vorher einfach selten auftrat. Wenn dann die Bedingung nachdem aufwachen nicht erneut geprüft wird und das Programm annimmt dass die Bedingung eingetreten ist, wird natürlich auf einem eigentlich inkonsistenten Stand weitergearbeitet.

Diese Probleme betrafen auch große Softwarefirmen, weswegen die Umstellung von Java 1.4 auf die weiteren Versionen doch langsamer vonstatten ging als eigentlich angenommen.

Sollen wir uns dein Programm mal anschauen Baopi?

Baopi · 21.10.10 17:27

Ja gerne, ich werde es mal kopieren
aber nicht lachen .... gut programmiert ist es nicht

sowas hatten wir vorher noch nicht in der Schule also keine objektorientierte Programmierung, keine Formulare usw. und ich stand unter Zeitdruck =D

Code :

import java.awt.*;
import javax.swing.*;
import java.awt.Toolkit;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JWindow;
import java.awt.Label;
 
public class PingPong extends JFrame
{
    private final Dimension dim = new Dimension(600,300);
    private final Dimension pos = Toolkit.getDefaultToolkit().getScreenSize();
    private Graphics2D bilder;
    private boolean[] druektasten = new boolean[7];
    private boolean xrechts=true,xlinks=false,xrechts2=false,xlinks2=true,xrechts3=true,xlinks3=false,xrechts4=false,xlinks4=true,da1=true,da2=false,da3=false,da4=false,sicher=true;
    private int groesseschl1=50,groesseschl2=50,kollisionoben=40,x3=dim.width/2,y3=dim.height/2,ballx=10,bally=10,punktr=0,punktl=0,x4=dim.width/2,y4=dim.height/2,x5=dim.width/2,y5=dim.height/2,x6=dim.width/2,y6=dim.height/2;
    private int y1=dim.height/2-groesseschl1/2,y2=dim.height/2-groesseschl2/2,test=1,einmalL,einmalR,test2=1,pf=0,pf2=0,test3=2,test4=2,neu=3,geschw1=150,geschw2=180,geschw3=210,geschw4=120,kolschl1=20,kolschl2=20,tasth=1,tastg=1;
    final static int hoch=0,runter=1,w=2,s=3,b=4,h=5,g=6;
    
    private Thread bewegung = new Thread()                  //Thread für die Bewegung der Schläger
    {                                                       
        public void run()                                   //Beginn des runns des Threads
        {
            while(true)                                     //Endlosschleife für die Schläger
            {
                bilder.clearRect(585,y1,5,groesseschl1);    //Schläger rechts wird "entfernt"
                bilder.clearRect(10,y2,5,groesseschl2);     //Schläger links wird "entfernt"
                if(druektasten[hoch])                       //überprüft ob die Variable druektasten[hoch] wahr ist
                {
                    if(y1>kollisionoben)                    //überprüft ob y1 des rechten Schlägers größer als die Variable kollisionoben ist
                    {
                        y1 -=20;                            //wenn dies zutrifft, dann wird die Variable y1 um 20 verringert (der Schläger1 geht nach oben)
                    }
                }
                if(druektasten[runter])                     //überprüft ob die Variable druektasten[runter] wahr ist
                {
                    if(y1<dim.height-groesseschl1-20)       //überprüft ob y1 des rechten Schlägers kleiner als die Höhe des Frames minus die größe des Schlägers minus 20 ist
                    {
                        y1 +=20;                            //wenn dies zutrifft, dann wird die Variable y1 um 20 erhöht (der Schläger1 geht nach unten)
                    }
                }
                if(druektasten[w])                          //überprüft ob die Variable druektasten[w] wahr ist
                {
                    if(y2>kollisionoben)                    //überprüft ob y2 des rechten Schlägers größer als die Variable kollisionoben ist
                    {
                        y2 -=20;                            //wenn dies zutrifft, dann wird die Variable y2 um 20 verringert (der Schläger2 geht nach oben)
                    }
                }
                if(druektasten[s])                          //überprüft ob die Variable druektasten[w] wahr ist
                {
                    if(y2<dim.height-groesseschl2-20)       //überprüft ob y2 des linken Schlägers kleiner als die Höhe des Frames minus die größe des Schlägers minus 20 ist
                    {
                        y2 +=20;                            //wenn dies zutrifft, dann wird die Variable y2 um 20 erhöht (der Schläger2 geht nach unten)
                    }
                }
                bilder.fillRect(585,y1,5,groesseschl1);     //zeichnet den rechten Schläger neu
                bilder.fillRect(10,y2,5,groesseschl2);      //zeichnet den linken Schläger neu
                try 
                {
                    sleep(50);                              //Pause für 50 Millisekunden (damit die Schläger nicht zu schnell sind)
                } 
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    };
    
    private Thread ball = new Thread()                      //Thread für den ersten Ball
    {
            public void run()                               //Beginn des runns des Threads
            {
                while(true)                                 //Endlosschleife
                {
                    while(xrechts)                          //Schleife für den Flug des ersten Balles nach rechts
                    {
                        if(da1)                             //überprüft ob da1 wahr ist
                        {
                            if(y3+20>=dim.height)           //wenn y3+20 größer oder gleich der Höhe des Frames ist
                            {
                                test=2;                     //wird test auf 2 gesetzt
                            }
                            else if(y3<=kollisionoben)      //wenn y3 kleiner oder gleich kollisionoben ist
                            {
                                test=1;                     //wird test auf 1 gesetzt
                            }
                            bilder.clearRect(x3,y3,ballx,bally);    //der Ball wird entfernt
                            x3 +=10;                        //x3 wird um 10 erhöht (der erste Ball fliegt nach rechts)
                            if(test==1)                     //wenn test gleich 1 ist
                            {
                                y3 +=10;                    //wird y3 um 10 erhöht (der erste Ball fliegt nach unten)
                            }
                            else if(test==2)                //wenn test gleich 2 ist
                            {
                                y3 -=10;                    //wird y3 um 10 verringert (der erste Ball fliegt nach oben)
                            }
                            bilder.fillOval(x3,y3,ballx,bally);     //der Ball wird gezeichnet
                            try 
                            {
                                sleep(geschw1);             //Pause für die Länge geschw1 (damit der erste Ball nicht zu schnell ist)
                            } 
                            catch (InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                            if(x3>580)                      //wenn x3 größer als 580 ist (also rechts aus dem Bild geht)
                            {
                                punktl +=1;                 //dann wird punktl um 1 erhöht
                                bilder.clearRect(x3,y3,ballx,bally);    //der Ball wird entfernt
                                da1=false;                  //da1 wird auf false gesetzt
                                neu +=1;                    //neu wird um 1 erhöht
                                x3=dim.width/2;             //x3 wird auf die Breite des Frames geteilt durch 2 gesetzt 
                                y3=dim.height/2;            //y3 wird auf die Höhe des Frames geteilt durch 2 gesetzt (dadurch ist er in der Mitte des Frames)
                                JWindow pkt2 = new PunkteL(100,100,-600/2-100,300/2,punktl,einmalL);    //die Klasse PunkteL wird aufgerufen und ihr werden Variablen übergeben
                                einmalL=1;                  //einmalL wird auf 1 gesetzt
                            }
                            if((x3>=580-20)&&(y3<=y1+kolschl1+groesseschl1/2)&&(x3>=585-20)&&(y3>=y1+kolschl1-groesseschl1/2)) //damit wird gesagt, dass wenn der erste Ball gegen den rechten Schläger kommt, dass
                            { 
                                xrechts=false;              //xrechts auf false gesetzt wird
                                xlinks=true;                //xlinks auf true gesetzt wird
                                if(geschw1>10)              //wenn die Geschwindigkeit des ersten Balls höher als 10 ist,
                                {
                                    geschw1 -=10;           //dann wird die Geschwindigkeit des ersten Balls um 10 verringert
                                }
                            }
                        }
                    }
                    while(xlinks)                           //die Schleife für den Flug des ersten Balles nach links
                    {
                        if(da1)                             //wenn da1 auf true ist
                        {
                            if(y3+20>=dim.height)           //wenn y3+20 größer oder gleich der Höhe des Frames ist
                            {
                                test=2;                     //wird test auf 2 gesetzt
                            }   
                            else if(y3<=kollisionoben)      //wenn y3 kleiner oder gleich kollisonoben ist
                            {
                                test=1;                     //wird test auf 1 gesetzt
                            }
                            bilder.clearRect(x3,y3,ballx,bally);    //der Ball wird entfernt
                            x3 -=10;                        //x3 wird um 10 verringert (der erste Ball fliegt nach links)
                            if(test==1)                     //wenn test gleich 1 ist
                            {
                                y3 +=10;                    //wird y3 um 10 erhöht (der erste Ball fliegt nach unten)
                            }
                            else if(test==2)                //wenn test gleich 2 ist
                            {
                                y3 -=10;                    //wird y3 um 10 verringert (der erste Ball fliegt nach oben)
                            }
                            bilder.fillOval(x3,y3,ballx,bally); //der erste Ball wird gezeichnet
                            try 
                            {
                                sleep(geschw1);             //Pause für die Höhe von geschw1 (damit der erste Ball nicht zu schnell ist)
                            } 
                            catch (InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                            if(x3<=0)                       //wenn x3 kleiner oder gleich 0 ist (also links aus dem Bild geht)
                            {
                                punktr +=1;                 //wird punktr um 1 erhöht
                                bilder.clearRect(x3,y3,ballx,bally); //der erste Ball wird entfernt
                                da1=false;                  //da1 wird auf false gesetzt
                                neu +=1;                    //neu wird um 1 erhöht
                                x3=dim.width/2;             //x3 wird auf die Breite des Frames geteilt durch 2 gesetzt
                                y3=dim.height/2;            //y3 wird auf die Höhe des Frames geteilt durch 2 gesetzt
                                JWindow pkt1 = new PunkteR(100,100,600/2,300/2,punktr,einmalR); //dke Klasse PunteR wird aufgerufen und ihr werden Variable übergeben
                                einmalR=1;                  //einmalR wird auf 1 gesetzt
                            }
                            if((x3<=20)&&(y3<=y2+kolschl2+groesseschl2/2)&&(x3<=20)&&(y3>=y2+kolschl2-groesseschl2/2))  //beschreibt, dass wenn der erste Ball gegen den linken Schläger kommt, dass
                            {
                                xlinks=false;               //xlinks auf false gestezt wird
                                xrechts=true;               //xrechts auf true gesetzt wird
                                if(geschw1>10)              //wenn geschw1 görßer als 10 ist
                                {
                                    geschw1 -=10;           //wird geschw1 um 10 verringert
                                }
                            }
                        }
                    }
                }
            }   
        };
    
    private Thread ball2 = new Thread() //das Gleiche wie bei dem ersten Ball nur für den zweiten Ball
    {
        public void run()
        {
            while(true)
            {
                while(xrechts2)             
                {
                    if(da2)
                    {
                        if(y4+20>=dim.height)
                        {
                            test2=2;
                        }
                        else if(y4<=kollisionoben)
                        {
                            test2=1;
                        }
                        bilder.clearRect(x4,y4,ballx,bally);
                        x4 +=10;
                        if(test2==1)
                        {
                            y4 +=10;
                        }
                        else if(test2==2)
                        {
                            y4 -=10;
                        }
                        bilder.fillOval(x4,y4,ballx,bally);
                        try 
                        {
                            sleep(geschw2);
                        } 
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                        if(x4>580)
                        {
                            punktl +=1;
                            bilder.clearRect(x4,y4,ballx,bally);
                            da2=false;
                            neu +=1;
                            x4=dim.width/2;
                            y4=dim.height/2;
                            JWindow pkt2 = new PunkteL(100,100,-600/2-100,300/2,punktl,einmalL);
                            einmalL=1;
                        }
                        if((x4>=580-20)&&(y4<=y1+kolschl1+groesseschl1/2)&&(x4>=585-20)&&(y4>=y1+kolschl1-groesseschl1/2))
                        {
                            xrechts2=false;
                            xlinks2=true;
                            if(geschw2>10)
                            {
                                geschw2 -=10;
                            }
                        }
                    }
                }
                while(xlinks2)
                {
                    if(da2)
                    {
                        if(y4+20>=dim.height)
                        {
                            test2=2;
                        }   
                        else if(y4<=kollisionoben)
                        {
                            test2=1;
                        }
                        bilder.clearRect(x4,y4,ballx,bally);
                        x4 -=10;
                        if(test2==1)
                        {
                            y4 +=10;
                        }
                        else if(test2==2)
                        {
                            y4 -=10;
                        }
                        bilder.fillOval(x4,y4,ballx,bally);
                        try 
                        {
                            sleep(geschw2);
                        } 
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                        if(x4<=0)
                        {
                            punktr +=1;
                            bilder.clearRect(x4,y4,ballx,bally);
                            da2=false;
                            neu +=1;
                            x4=dim.width/2;
                            y4=dim.height/2;
                            JWindow pkt1 = new PunkteR(100,100,600/2,300/2,punktr,einmalR);
                            einmalR=1;
                        }
                        if((x4<=20)&&(y4<=y2+kolschl2+groesseschl2/2)&&(x4<=20)&&(y4>=y2+kolschl2-groesseschl2/2))
                        {
                            xlinks2=false;
                            xrechts2=true;
                            if(geschw2>10)
                            {
                                geschw2 -=10;
                            }
                        }
                    }
                }
            }
        }
    };
    
        private Thread ball3 = new Thread() //das Gleiche wie bei dem ersten Ball nur für den dritten Ball
        {
            public void run()
            {
                while(true)
                {
                    while(xrechts3)             
                    {
                        if(da3)
                        {
                            if(y5+20>=dim.height)
                            {
                                test3=2;
                            }
                            else if(y5<=kollisionoben)
                            {
                                test3=1;
                            }
                            bilder.clearRect(x5,y5,ballx,bally);
                            x5 +=10;
                            if(test3==1)
                            {
                                y5 +=10;
                            }
                            else if(test3==2)
                            {
                                y5 -=10;
                            }
                            bilder.fillOval(x5,y5,ballx,bally);
                            try 
                            {
                                sleep(geschw3);
                            } 
                            catch (InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                            if(x5>580)
                            {
                                punktl +=1;
                                bilder.clearRect(x5,y5,ballx,bally);
                                da3=false;
                                neu +=1;
                                x5=dim.width/2;
                                y5=dim.height/2;
                                JWindow pkt2 = new PunkteL(100,100,-600/2-100,300/2,punktl,einmalL);
                                einmalL=1;
                            }
                            if((x5>=580-20)&&(y5<=y1+kolschl1+groesseschl1/2)&&(x5>=585-20)&&(y5>=y1+kolschl1-groesseschl1/2))
                            {
                                xrechts3=false;
                                xlinks3=true;
                                if(geschw3>10)
                                {
                                    geschw3 -=10;
                                }
                            }
                        }
                    }
                    while(xlinks3)
                    {
                        if(da3)
                        {
                            if(y5+20>=dim.height)
                            {
                                test3=2;
                            }   
                            else if(y5<=kollisionoben)
                            {
                                test3=1;
                            }
                            bilder.clearRect(x5,y5,ballx,bally);
                            x5 -=10;
                            if(test3==1)
                            {
                                y5 +=10;
                            }
                            else if(test3==2)
                            {
                                y5 -=10;
                            }
                            bilder.fillOval(x5,y5,ballx,bally);
                            try 
                            {
                                sleep(geschw3);
                            } 
                            catch (InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                            if(x5<=0)
                            {
                                punktr +=1;
                                bilder.clearRect(x5,y5,ballx,bally);
                                da3=false;
                                neu +=1;
                                x5=dim.width/2;
                                y5=dim.height/2;
                                JWindow pkt1 = new PunkteR(100,100,600/2,300/2,punktr,einmalR);
                                einmalR=1;
                            }
                            if((x5<=20)&&(y5<=y2+kolschl2+groesseschl2/2)&&(x5<=20)&&(y5>=y2+kolschl2-groesseschl2/2))
                            {
                                xlinks3=false;
                                xrechts3=true;
                                if(geschw3>10)
                                {
                                    geschw3 -=10;
                                }
                            }
                        }
                    }
                }
            }
        };
        
        private Thread ball4 = new Thread() //das Gleiche wie bei dem ersten Ball nur für den vierten Ball
        {
            public void run()
            {
                while(true)
                {
                    while(xrechts4)             
                    {
                        if(da4)
                        {
                            if(y6+20>=dim.height)
                            {
                                test4=2;
                            }
                            else if(y6<=kollisionoben)
                            {
                                test4=1;
                            }
                            bilder.clearRect(x6,y6,ballx,bally);
                            x6 +=10;
                            if(test4==1)
                            {
                                y6 +=10;
                            }
                            else if(test4==2)
                            {
                                y6 -=10;
                            }
                            bilder.fillOval(x6,y6,ballx,bally);
                            try 
                            {
                                sleep(geschw4);
                            } 
                            catch (InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                            if(x6>580)
                            {
                                punktl +=1;
                                bilder.clearRect(x6,y6,ballx,bally);
                                da4=false;
                                neu +=1;
                                x6=dim.width/2;
                                y6=dim.height/2;
                                JWindow pkt2 = new PunkteL(100,100,-600/2-100,300/2,punktl,einmalL);
                                einmalL=1;
                            }
                            if((x6>=580-20)&&(y6<=y1+kolschl1+groesseschl1/2)&&(x6>=585-20)&&(y6>=y1+kolschl1-groesseschl1/2))
                            {
                                xrechts4=false;
                                xlinks4=true;
                                if(geschw4>10)
                                {
                                    geschw4 -=10;
                                }
                            }
                        }
                    }
                    while(xlinks4)
                    {
                        if(da4)
                        {
                            if(y6+20>=dim.height)
                            {
                                test4=2;
                            }   
                            else if(y6<=kollisionoben)
                            {
                                test4=1;
                            }
                            bilder.clearRect(x6,y6,ballx,bally);
                            x6 -=10;
                            if(test4==1)
                            {
                                y6 +=10;
                            }
                            else if(test4==2)
                            {
                                y6 -=10;
                            }
                            bilder.fillOval(x6,y6,ballx,bally);
                            try 
                            {
                                sleep(geschw4);
                            } 
                            catch (InterruptedException e)
                            {
                                e.printStackTrace();
                            }
                            if(x6<=0)
                            {
                                punktr +=1;
                                bilder.clearRect(x6,y6,ballx,bally);
                                da4=false;
                                neu +=1;
                                x6=dim.width/2;
                                y6=dim.height/2;
                                JWindow pkt1 = new PunkteR(100,100,600/2,300/2,punktr,einmalR);
                                einmalR=1;
                            }
                            if((x6<=20)&&(y6<=y2+kolschl2+groesseschl2/2)&&(x6<=20)&&(y6>=y2+kolschl2-groesseschl2/2))
                            {
                                xlinks4=false;
                                xrechts4=true;
                                if(geschw4>10)
                                {
                                    geschw4 -=10;
                                }
                            }
                        }
                    }
                }
            }
        };
    
    public PingPong()
    {
        super("PingPong");                          //Frame wird erzeugt
        setDefaultCloseOperation(EXIT_ON_CLOSE);    //Wenn der Frame geschlossen wird wird die DOS-BOX beendet
        setResizable(false);                        //der Frame wird in der Größe unveränderbar
        setSize(dim);                               //die Größe des Frames wird gesetzt
    //  ImageIcon icon1 = new ImageIcon( PingPong.class.getResource( "tennisfeld.gif" ) );
    //  JLabel tennis = new JLabel( icon1 );
    //  add( tennis, BorderLayout.LINE_START );
        setLocation( (pos.width  - dim.width ) / 2,(pos.height - dim.height) / 2 ); //die Position des Frames wird bestimmt
 
 
 
        addKeyListener(new KeyAdapter()             //Beginn des KeyListeners
        {
            public void keyPressed(KeyEvent evt)    //bei gedrückter Taste
            {
                pruef(evt.getKeyCode(),true);       //der Variable pruef wird der Tastencode der gedrückten Taste und den Wert true übergeben
            }
            public void keyReleased(KeyEvent evt)   //bei loslassen der gedrückten Taste
            {
                pruef(evt.getKeyCode(),false);      //der Variable pruef wird der Tastencode der losgelassenen Taste und den Wert false übergeben
            }
            public void keyTyped(KeyEvent evt2)     //bei kurzem drücken einer Taste
            {
                if(druektasten[b])                  //wenn druektasten[b] wahr ist
                {
                    if(neu>0)                       //wenn neu größer als 0 ist
                    {
                        neu -=1;                    //wird neu um 1 verringert
                        if(da1==false)              //wenn da1 gleich false ist
                        {
                            da1=true;               //wird da1 auf true gestezt
                            geschw1=150;            //wird die Geschwindigkeit von dem ersten Balls auf 150 gesetzt
                        }
                        else if(da2==false)         //wenn da2 gleich false ist
                        {
                            da2=true;               //wird da2 auf true gesetzt
                            geschw2=180;            //wird die Geschwindigkeit von dem zweiten Balls auf 180 gesetzt
                        }
                        else if(da3==false)         //wenn da3 gleich false ist
                        {
                            da3=true;               //wird da3 auf true gesetzt
                            geschw3=210;            //wird die Geschwindigkeit von dem dritten Balls auf 210 gesetzt
                        }
                        else if(da4==false)         //wenn da4 gleich false ist
                        {
                            da4=true;               //wird da4 auf true gesetzt
                            geschw4=170;            //wird die Geschwindigkeit von dem vierten Balls auf 170 gesetzt
                        }
                    }
                }
                if(druektasten[h])                  //wenn druektasten[h] wahr ist
                {
                    if(tasth==1)                    //wenn tasth gleich 1 ist
                    {
                        if(y1<=kollisionoben)       //wenn y1 kleiner oder gleich kollisionoben ist
                        {
                            groesseschl1=300;       //wird die größe des rechten Schlägers auf 300 gesetzt
                            kolschl1=100;           //die Kollision des rechten schlägers wird auf 100 gesetzt
                            tasth=0;                //tasth wird auf 0 gesetzt
                        }
                    }   
                    else if(tasth==0)               //wenn tasth gleich 0 ist
                    {
                        groesseschl1=50;            //wird die Größe des rechten Schlägers auf 50 gesetzt
                        kolschl1=20;                //die Kolllision des rechten Schlägers wird auf 20 gesetzt
                        tasth=1;
                        bilder.clearRect(585,0,5,300);  //der rechte Schläger wird entfernt
                    }
                }
                if(druektasten[g])                  //das Gleiche wie bei Taste h nur mit der Taste g und dem linken Schläger
                {
                    if(tastg==1)
                    {
                        if(y2<=kollisionoben)
                        {
                            groesseschl2=300;
                            kolschl2=100;
                            tastg=0;
                        }
                    }
                    else if(tastg==0)
                    {
                        groesseschl2=50;
                        kolschl2=20;
                        tastg=1;
                        bilder.clearRect(10,0,5,300);
                    }
                }
            }
            private void pruef(int taste,boolean wert)
            {
                switch(taste)                   
                {
                    case KeyEvent.VK_UP:            //wenn die Taste Hoch gedrückt ist
                        druektasten[hoch]=wert;     //wird druektasten[hoch] auf den Wert von wert gesetzt
                        break;                      //Abbruch
                    case KeyEvent.VK_DOWN:          //Wenn die Taste Runter gedrückt ist
                        druektasten[runter]=wert;   //wird druektasten[runter] auf den Wert von wert gesetzt
                        break;                      //Abbruch
                    case KeyEvent.VK_W:             //wenn die Taste W gedrückt ist
                        druektasten[w]=wert;        //wird druektasten[w] auf den Wert von wert gesetzt
                        break;                      //Abbruch
                    case KeyEvent.VK_S:             //wenn die Taste S gedrückt ist
                        druektasten[s]=wert;        //wird druektasten[s] auf den Wert von wert gesetzt
                        break;                      //Abbruch
                    case KeyEvent.VK_B:             //wenn die Taste B gedrückt ist
                        druektasten[b]=wert;        //wird druektasten[b auf den Wert von wert gesetzt
                        break;                      //Abbruch
                    case KeyEvent.VK_H:             //wenn die Taste H gedrückt ist
                        druektasten[h]=wert;        //wird druektasten[h] auf den Wert von wert gesetzt
                        break;                      //Abbruch
                    case KeyEvent.VK_G:             //wenn die Taste G gedrückt ist
                        druektasten[g]=wert;        //wird druektasten[g] auf den Wert von wert gesetzt
                        break;                      //Abbruch
                    default:;                       //wenn nichts davon zutrifft
                }
            }
        });
        setVisible(true);                           //der Frame wird gezeigt
        bilder = (Graphics2D)this.getGraphics();    //damit kann gezeichnet werden
    }
    
    public static void main(String[] args)
    {
        new PingPong().start();
    }
    private void start()
    {
        JWindow pkt1 = new PunkteR(100,100,600/2,300/2,punktr,einmalR);         //die Klasse PunkteR wird aufgerufen und ihr werdne Variablen übergeben
        JWindow pkt2 = new PunkteL(100,100,-600/2-100,300/2,punktl,einmalL);    //die Klasse PunkteL wird aufgerufen und ihr werdne Variablen übergeben
        bewegung.start();                                                       //der Thread Bewegung wird gestartet
        ball.start();                                                           //der Thread für den ersten Ball wird gestartet
        ball2.start();                                                          //der Thread für den zweiten Ball wird gestartet
        ball3.start();                                                          //der Thread für den dritten Ball wird gestartet
        ball4.start();                                                          //der Thread für den vierten Ball wird gestartet
    }
}

SPiKEe · 21.10.10 20:20

da die klassen PunkteL.java und PunkteR.java fehlen ist ein compilen nicht möglich ...
bitte diese klassen auch noch posten *und eventuell weitere* damit wir das ding compilen und testen können

dann die frage : warum 4 bälle und warum für jeden eigene variablien und eigene threads ?
spielst du mit 4 bällen gleichzeitig ?

die funktion für B H und G sind nicht ersichtlich ... bitte mal erklären was diese machen

warum sind PunkteR und PunkteL vom Type JWindow ? ... werden diese sichtbar dagestellt ? wofür dienen sie ? was ist in den klassen drin ? *bitte posten*

deine threads werden falsch invoked ...

du musst schreiben

(new Thread()).start();

und nicht einfach

Thread.start();

ist klar das das so nichts werden kann ...

wie gesagt ... mal bitte die fragen beantworten und fehlendes material posten ...

Baopi · 23.10.10 00:41

ja ich spiele mit 4 Bällen zur gleichen Zeit
die Taste "B" ist um einen neuen Ball einfügen zu können
die Taste "G" und "H" sind nur um die Schläger nach einer bestimmten Bedingung so groß zu machen dass die Bälle nicht mehr aus dem spiel fliegen können war zu dies diente nur zu Testzwecken.

(new Thread()).start(); habe ich getestet doch da gibt der compiler nur iene Fehlermeldung aus

und der rest kommt jetz

Code :

//linke Punktetafel
 
import java.awt.*;
import java.awt.event.*;
import javax.swing.JWindow;
import javax.swing.JLabel;
import javax.swing.border.Border;
import javax.swing.border.LineBorder;
public class PunkteL extends JWindow
  {
    private JLabel label;
    public PunkteL(int x,int y,int posx, int posy,int punkt,int einmal)
    {
        Border border = LineBorder.createBlackLineBorder();         //Umrandung für das Window
        setSize(x, y);                                              //Größe des Windows
        Dimension d = Toolkit.getDefaultToolkit().getScreenSize();  //übergibt d die Bildschirmgröße
        setLocation((d.width-getSize().width)/2+posx+(getSize().width)/2,(d.height-getSize().height)/2-posy+(getSize().height)/2); //die Position wird gesetzt
        label = new JLabel(String.valueOf(punkt));                  //Label mit der Ausgabe des Werts der Variable punkt wird wird bestimmt
        label.setFont(new Font("Arial",Font.BOLD,50));              //die Schriftart und Größe wird des Labels wird bestimmt
        label.setBorder(border);                                    //Umrandung für das Label
        add(label);                                                 //Label wird hinzugefügt    
        setVisible(true);                                           //Window wird sichtbar gemacht
    }
}

Code :

//rechte Punktetafel
 
import java.awt.*;
import java.awt.event.*;
import javax.swing.JWindow;
import javax.swing.JLabel;
import javax.swing.border.Border;
import javax.swing.border.LineBorder;
public class PunkteR extends JWindow
  {
    private JLabel label;
    public PunkteR(int x,int y,int posx, int posy,int punkt,int einmal)
    {
        Border border = LineBorder.createBlackLineBorder();         //Umrandung für das Window
        setSize(x, y);                                              //Größe des Windows
        Dimension d = Toolkit.getDefaultToolkit().getScreenSize();  //übergibt d die Bildschirmgröße
        setLocation((d.width-getSize().width)/2+posx+(getSize().width)/2,(d.height-getSize().height)/2-posy+(getSize().height)/2);  //die Position wird gesetzt
        label = new JLabel(String.valueOf(punkt));                  //Label mit der Ausgabe des Werts der Variable punkt wird wird bestimmt
        label.setFont(new Font("Arial",Font.BOLD,50));              //die Schriftart und Größe wird des Labels wird bestimmt
        label.setBorder(border);                                    //Umrandung für das Label
        add(label);                                                 //Label wird hinzugefügt        
        setVisible(true);                                           //Window wird sichtbar gemacht
    }
}

und nochmal danke für die Hilfe

SPiKEe · 23.10.10 14:05

gut ... nach dem ich dran rumgebastelt hab ohne ende und es dann doch irgendwie zum laufen bekommen hab muss ich sagen

SCHREIBE DAS BITTE NOCHT MAL NEU

es geht garnicht wie viele fehler da drin sind
wie viele neu-instanzierungen ... wie viele FEHLER-instanzierungen
überladungen
duplikationen
logik-fehler

ne ... also davon abgesehen das ich das schon beim ersten überfliegen des codes gesehen hab und mir nur gedacht hab : oh gott wird das witzig ... aber ich hab mich im vor-post ja noch zurück gehalten ...
aber jetzt reicht es mir ...

ich kann mich gerne dran machen und versuchen das noch mal von grund auf neu strukturieren und neu implementieren ...
aber so wie das jetzt ist es kein wunder das es einfach nicht funktioniert ...
von der extremen auslastung abgesehen ...
kleiner tipp : es liegt nicht daran das überhaupt nichts passiert ... es liegt nur daran das NICHTS gezeichnet wird ...
denk über diesen tipp nach und versuch mal was dagegen zu tun ...

wenn du das angebot annehmen willst das ich mal versuche das ganze neu zu implementieren schreib es einfach

***zeja*** · 23.10.10 14:19

Das starten der Threads ist schon okay.

Laufen tut das Spiel bei mir auch nicht. Was aber auch kein Wunder ist, da ich einen Dual-Core habe und die Threads damit wirklich gegeneinander laufen können. Das Problem ist dass du ohne jegliche Synchronisierung auf die selben Variablen von allen Threads zugreifst.

Dieses Problem solltest du erstmal beheben, denn so wie ich das spontan sehe, ist es für die meisten Variablen auch gar nicht nötig. Jeder Ball sollte seinen eigenen Status und seine eigenen Variablen haben.

Als Regel: Ohne Synchronisierung darfst du nur auf Variablen zugreifen, die nicht mehr veränderlich sind.
Bei einer InterruptedException in einem Thread, solltest du die Endlosschleife verlassen und nicht nur den Fehler ausgeben

***zeja*** · 23.10.10 15:05

SPiKEe: Das dachte ich mir auch

Irgendwo hier im Forum gibt's schon nette Pong-Implementierung, also neu schreiben von dir hat für ihn ja keinen Lerneffekt

SPiKEe · 23.10.10 16:52

doppel-post FTW

was das mit den threads angeht ... ich habs mal anstatt mit anonymen-inneren-klassen mal mit diskreten klassen probiert *also nichts verschachtelt sondern dierekt als eigene klasse* ... effekt leider der selbe
das man threads auch so deklarieren und starten kann wusste ich nicht ... aber wenns laut dir keinen unterschied macht glaub ich dir das einfach mal

das mit der parallel-läufigkeit auf multi-core systemen halte ich für wenig warscheinlich
ich habe es soweit zum laufen bekommen das ich ungefähr eine runde lange hin-und-her spielen konnte ...
so bald allerdings der ball ausm spiel lief is das teil in dem sinne nicht abgestürzt ... ich konnte also mit der funktion einen neuen sich sogar bewegenden ball hinzufügen ... aber irgendwann nahmen die updates dermaßen zu das die app garnicht mehr dazu kam zu zeichnen ... hier muss auf jedenfall synchronized werden ...
und ich habe nur ein 1-core-system ...

und das mit der neu-implementation von mir war auch eingentlich mehr als hilfe-stellung gemeint ... nicht das ich seine arbeit mache ...
das es hier beispiele noch und nöcher gibt ... ich denke da wird die sufu ordentlich was liefern können ...

also ... um mich noch mal etwas verständlicher auszudrücken

hilfe von uns : ja ...
abnehmen von arbeit : nein

entscheid also was du möchtest

Baopi · 24.10.10 15:47

nee wenn dann mach ich das selbst
aber ich versteh nich warum dass dann bie uns in der Schule an dem einen Platz ohne Probleme funktioniert hat .... ich konnte mit allen Bällen spielen und es ist auch nicht abgestürzt oder sonstiges .... egal ob ich hin und her gespielt hab oder ob der Ball raus geflogen ist ..... das hat alles funktioniert

***zeja*** · 24.10.10 15:50

Inkorrekte Programm die Threads verwenden können durchaus auf einem System laufen und auf dem anderen nicht.... Solang das Programm nicht korrekt ist braucht man da nicht weiter drüber nach grübeln warum das so ist, da dies viel zu viel mit dem Timing der einzelnen Komponenten im System zu tun hat.

tut orials.de	tut verbinden	tut dir helfen	tut kooperieren
©2000-2012 tutorials.de Alle Rechte vorbehalten	tut informieren » Impressum » Nutzungsregeln » Netiquette » Team » Redaktion	» Tutorials » Videotutorials » Showroom » Events & Contests » Chat » RSS-Feed » Blogs	» der-webdesigner.net » DesignerInAction » Design Nation » Directorforum » Flashhilfe » PHP-Resource » PHPwelt » PSD-Tutorials

Themen-Optionen

Anzeige

Ähnliche Themen

Probleme beim Ausführen einer jar-Datei im Browser

Probleme beim Ausführen meiner .exe

c++ schritte beim ausführen..

Probleme beim Ausführen eines PHP-Scriptes in der Kommandozeile

Probleme beim Ausführen von Test Client meines EJB mit Eclipse, Jboss und Lomboz

Stichworte

E-Mail:

Abonnieren Abbestellen