Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hallo zusammen,
gibt es eine Methode, die immer nur dann aufgerufen wird, wenn die Fenstergröße des Applets bzw. des Browsers verändert wird.
Oder ist es möglich diese selbst mithilfe eines Threads zu schreiben, der die Fenstergröße ständig im Auge hält? (Wie wäre dann dafür der Befehl?)
Grund für die Frage: Wenn die Fenstergröße verändert wird, verschwinden die Paint elemente, die dann neu gezeichnet werden mussen, aber halt nur dann.
Bitte um Hilfe!!
was denn für einen Fehler??
Die Elemente sind ja in Arrays gespeichert, aber ich will nicht in Abständen von 15 ms immer
eine Schleife bis ca. 100 durchlaufen lassen, sondern nur dann wenn es nötig ist
(wenn die Fenstergröße geändert wird)
also die Paint-Elemente werden auf einer separaten Canvas gezeichnet.
Da aber beim verändern der Größe die paint methode neu aufgerufen wird, sind alle bis dahin gemalten Objekte auf dem Canvas weg(Kreise, Lines...);
Das macht allerdings nicht, denn ich habe die Koordinaten in einem Array gespeichert. Aber ich muss halt nun wissen, wann ich die Elemente des Array auf das Canvas zeichnen muss.
Ich poste am besten mal den Code, auch wenn es etwas mehr ist:
Code:
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.JOptionPane;
public class Achtung extends Applet implements Runnable, KeyListener
{
Label eins,zwei,opt;
Font schrift,infos;
Thread myThread;
MyCanvas feld=new MyCanvas();
double z = Math.random();
int x=(int) (z*880);
double zz = Math.random();
int y=(int) (zz*570);
String richtung="rechts";
String alterichtung="";
boolean jo=false;
int punkte2=0;
boolean leeren=false;
boolean nachste=false;
boolean ende=false;
int ovalx [] = {x};
int ovaly [] = {y};
int puffer[];
public void init()
{ setLayout(null);
setBackground(Color.blue);
resize(1000,670); setFocusable(true);
schrift = new Font("Monospaced", Font.BOLD, 50);
infos = new Font("Monospaced", Font.BOLD, 20);
eins = new Label("0");
eins.setBounds(945,40,50,50);
eins.setFont(schrift);
eins.setForeground(Color.white);
add(eins);
feld.setBounds(7,20,890,580);
feld.setBackground(Color.black);
feld.addKeyListener(this);
add(feld);
zwei = new Label(punkte2 +"");
zwei.setBounds(945,130,50,50);
zwei.setFont(schrift);
zwei.setForeground(Color.white);
add(zwei);
opt = new Label("");
opt.setBounds(30,608,250,45);
opt.setFont(infos);
opt.setForeground(Color.black);
opt.addKeyListener(this);
add(opt);
addKeyListener(this);
}
public void keyPressed( KeyEvent k ){
switch (k.getKeyCode()){
case KeyEvent.VK_DOWN : jo=true; richtung="unten"; if(nachste==false && ende==false) {start();}
break;
case KeyEvent.VK_UP : jo=true; richtung="oben"; if(nachste==false && ende==false) {start();}
break;
case KeyEvent.VK_LEFT : jo=true; richtung="links"; if(nachste==false && ende==false) {start();}
break;
case KeyEvent.VK_RIGHT : jo=true; richtung="rechts"; if(nachste==false && ende==false) {start();}
break;
case KeyEvent.VK_SPACE : if(nachste==true && ende==false){neu(); }
break;
case KeyEvent.VK_ENTER : if(opt.getText().equals("gedrückt")){opt.setText("");}else{opt.setText("gedrückt");}
break;
}
}
public void keyReleased(KeyEvent k){}
public void keyTyped(KeyEvent k){}
public void start(){
if(myThread==null && jo==true){myThread=new Thread(this); myThread.start(); ovalx=new int[0];
ovaly=new int[0]; }
}
public void run(){
Thread thisThread = Thread.currentThread();
while(myThread == thisThread){
feld.repaint();
try{myThread.sleep(17);}catch(InterruptedException e){}
if(richtung=="rechts" && jo==true){x++; hinzufugen();}
else if(richtung=="links" && jo==true){x--; hinzufugen();}
else if(richtung=="oben" && jo==true){y--; hinzufugen();}
else if(richtung=="unten" && jo==true){y++; hinzufugen();}
if(x>885 || x<0 || y<0 || y>575){stop();
punkte2++; zwei.setText(""+punkte2); if(punkte2<5){nachste=true;}else{opt.setText("Spiel zu Ende"); ende=true;}
}
}
}
public void hinzufugen(){
puffer = new int[ovalx.length];
for(int i=0; i<ovalx.length; i++){puffer[i] = ovalx[i];}
ovalx = new int[puffer.length+1];
for(int a=0; a< puffer.length; a++){ovalx[a]=puffer[a];}
ovalx[puffer.length]=x;
puffer = new int[ovaly.length];
for(int i=0; i<ovaly.length; i++){puffer[i] = ovaly[i];}
ovaly = new int[puffer.length+1];
for(int a=0; a< puffer.length; a++){ovaly[a]=puffer[a];}
ovaly[puffer.length]=y;
for(int i=0; i<ovalx.length-1; i++){
if(ovalx[ovalx.length-1]==ovalx[i]){
if(ovaly[ovaly.length-1]==ovaly[i]){ punkte2++; zwei.setText(""+punkte2);stop();
if(punkte2<5){nachste=true; }else{opt.setText("Spiel zu Ende"); ende=true;}}
}
}
}
public void stop(){
myThread = null; jo=false; ovalx=new int[0];
ovaly=new int[0];
}
public void neu(){setFocusable(true);
leeren=true;
ovalx=new int[1];
ovaly=new int[1];
z = Math.random(); x=(int) (z*880);
zz = Math.random(); y=(int) (zz*570);
ovalx[0]=x;
ovaly[0]=y;
feld.repaint(); nachste=false; jo=false;; start();
}
class MyCanvas extends Canvas{
public void paint(Graphics g){
g.setColor(Color.red);
//for(int b=0; b<ovalx.length; b++){
g.fillOval(ovalx[ovalx.length-1],ovaly[ovalx.length-1],5,5);//}
}
public void update (Graphics g){
if(leeren==true){g.clearRect(0,0,890,580);leeren=false;} paint(g);
}
}
}
funktionieren, ist schon fast(!) sowas wie "Zufall". Eigentlich vergleicht man Strings mit "equals":
Code:
if(richtung.equals(rechts")) ...
Die "richtung" als String zu speichern ist aber sowieso *wuah-ha-ha* :autsch: . Stattessen solltest du konstante ints oder besser eine enum verwenden:
Code:
private static final int RICHTUNG_OBEN = 1;
private static final int RICHTUNG_UNTEN = 2;
private int richtung = RICHTUNG_OBEN;
...
if (richtung == RICHTUNG_OBEN) ...
oder besser:
Code:
private enum Richtung
{
OBEN, UNTEN, RECHTS, LINKS;
}
private Richtung richtung = Richtung.OBEN;
Dann kann man (in beiden Fällen!) solche Abfragen wie
solltest du die Koordinaten der Punkte NICHT (getrennt nach x und y) in zwei Arrays speichern, die bei JEDEM hinzugefügten Element neu vergrößert werden müssen. (Das ist nichtnur ineffizient, sondern auch fehleranfällig, schwer wartbar, und fürht zu solchem Quäl-Code wie bei deinem Buffer-Kopieren)
ETWAS besser wäre es, eine ArrayList verwenden, wo du einfach neue Punkte hinzufügen und auch wieder löschen kannst. (Und letzteres ist bei deinem bisherigen Konzept ja noch garnicht vorgesehen)
Code:
ArrayList<Point> punkte = new ArrayList<Point>();
...
punkte.add(new Point(x,y));
...
punkte.remove(3);
Vermutlich wäre es aber am sinnvollsten, die Punkte in einer verketteten Liste zu speichern (bzw. in einer Klasse, die wie eine verkettete Liste funktioniert). Schließlich wird immer VORNE ein Punkt hinzugefügt, und (wenn die Schlange ihre Maximallänge erreicht hat) HINTEN ein Element entfernt, und das geht mit einer LinkedList am schnellsten. Diese Klasse könnte dann evlt. auch das Zeichnen der Schlange übernehmen, aber dazu kommen wir gleich...
Ob das Thread-Handling so in Ordnung ist, hab ich jetzt mal nicht durchgedacht.
Aber wir nähern uns deinem eigentlichen Problem (langsam, aber sicher :wink: )
Das Problem, das du beschrieben hast, tritt NICHT nur auf, wenn man die Fenstergröße ändert, sondern z.B. auch, wenn man ein anderes Fenster VOR dein Applet-Fenster schiebt und dann wieder wegnimmt. Der Grund dafür ist, dass hier
immer nur das LETZTE oval gezeichnet wird. Es müssen dort aber immer alle (ja, IMMER ALLE) ovals gezeichnet werden, die gerade auf dem Bildschirm zu sehen sind. (Statt fillOval könntest du auch fillRect verwenden, das wäre vmlt. noch ein Stück schneller).
Hm. Das wars fürs erste. Und... lies mal ein paar Tutorials.
Boa, vielen vielen vielen Dank für deine ausführliche Antwort und die unzähligen Tipps!!!!!
Also wie ich es verstanden habe, muss ich dann wohl doch die Schleife in der Paint()-Methode ausführen, (hatte sie extra als Kommentar gesetzt).
Ich traue mich schon fast gar nicht mehr nachzufragen nach der ausführlichen Antwort, aber ich tue es einfach mal trotzdem:
Gibt es noch eine andere Möglichkeit, wie ich die Schlange umsetzten kann (also ohne alle 15 ms immer eine Schleife bis 100 durchlaufen zu lassen, da mein Pc dabei nach ein paar Sekunden ziemlich anfängt zu drehen)--> vielleicht indem man die bisher gezeichnete Linie(n) als Bild speichert und das Bild statt der hundertern Punkte zeichnet, und darauf dann immer den einen zusätzlichen punkt, der bei jedem Durchlauf hinzukommt.
Oder gibt es noch eine ganz andere Möglichkeit eine solche immer länger werdende Schlange zu zeichnen??
Und wenn man ein Bild benutzt, kann ich dann die Pixelfarbe auslesen, um zu prüfen, ob die Schlange in sich rein fährt?
Zu der ArrayList: Wie kann ich wenn ich zb schon 3 Punkte in der ArrayList habe, wie kann ich sie in der Paint()Methode zeichnen lassen? Oder kann man alle Punkte vll sogar auf einmal zeichnen lassen, ohne eine Schleife zu verwenden?
Vielleicht noch eine letzte Frage: Ich suche schon seit längerem ein gutes Tutorial-Buch, das aktuell ist und dich wichtigsten Tipps und Strukturen erläutert. Könntest du mir unter Umständen eines Empfehlen, aus dem du deine Erfahrungen geschöpft hast?
@Marco13: Ich will dir nochmals für deine großartige Hilfe danken und dir sagen, wie sehr ich dies zu schätzen weiß :applaus:
Gibt es noch eine andere Möglichkeit, wie ich die Schlange umsetzten kann (also ohne alle 15 ms immer eine Schleife bis 100 durchlaufen zu lassen, da mein Pc dabei nach ein paar Sekunden ziemlich anfängt zu drehen)
Das sollte er eigentlich nicht. Aber ... die Positionen der Ovals werden ja in jedem Schritt nur um EINEN Pixel verändert. Wenn du viele Ovale hintereinander hast, bleiben von fast allen Ovalen nur ZWEI Pixel übrig, die tatsächlich benötigt werden. Trotzdem wird immer ein komplettes Oval mit Radius 5 gezeichnet (und ein Oval zu zeichnen ist SEHR viel aufwändiger als ein Rechteck, selbst dann, wenn das Oval so klein ist, dass es schon fast wie ein Rechteck aussieht). Die drawOval durch drawRect zu ersetzen könnte da ein bißchen was bringen. Dann könntest du auch z.B. in jedem Schritt 5 Pixel weit laufen - dann bräuchtest du nur alle 5*17 ms neu zu zeichnen, und die Schlange würde sich genauso schnell bewegen, wie vorher, aber nur 1/5 des Rechenpowers benötigen. Du könntest dafür vielleicht ein
private static final int STEP_SIZE = 5;
verwenden, den du überall verwendest, anstatt die Schrittweite "hardcodiert" in den Quelltext zu schreiben, oder festlegen, dass die Schrittgröße die gleiche ist, wie die Dicke der Schlange. (Was von beidem sinnvoller ist, müßte man sich überlegen)
--> vielleicht indem man die bisher gezeichnete Linie(n) als Bild speichert und das Bild statt der hundertern Punkte zeichnet, und darauf dann immer den einen zusätzlichen punkt, der bei jedem Durchlauf hinzukommt.
... Und wenn man ein Bild benutzt, kann ich dann die Pixelfarbe auslesen, um zu prüfen, ob die Schlange in sich rein fährt?
Das geht prinzipiell natürlich schon. Du könntest dann auch Pixel am ENDE der Schlange wieder löschen. Die Möglichkeit, die "Kollisionserkennung" mit Hilfe der gezeichneten Pixel zu machen wirkt verlockend, und wäre vmtl. auch relativ schnell. Du kannst es versuchen. Es wird sicher gehen. (Ich würde es anders versuchen, aber davon musst du dich nicht beeinflussen lassen :wink: )
Zu der ArrayList: Wie kann ich wenn ich zb schon 3 Punkte in der ArrayList habe, wie kann ich sie in der Paint()Methode zeichnen lassen? Oder kann man alle Punkte vll sogar auf einmal zeichnen lassen, ohne eine Schleife zu verwenden?
Der Tipp mit der ArrayList bezog sich in erster Linie darauf, dass dein "dynamisch wachstender Array" in dieser Form ... tja ... einfach schlecht war. Die Funktionalität, die du dort brauchtest und (mit viel Rumkopiererei in der "hinzufügen"-Methode) selbst gebaut hattest, wird von der ArrayList schon fix und fertig angeboten. Und auch noch deutlich schneller, komfortabler und flexibler.
Besser als eine ArrayList wäre aber (wie ich auch sagte) eine eigene Klasse. Bisher hast du EINE Klasse. Nämlich das Applet, das alles macht. Wie du dir vorstellst, dort evtl. noch eine ZWEITE Schlange einzubauen, weiß ich nicht. (Das würde mit Sicherheit im absoluten Chaos enden). Die Idee bei der Objektorientierten Programmierung ist, sich zu überlgen, welche Objekte man hat, und welche Eigenschaften (Variablen) und "Funktionen" diese Objekte haben. In deinem Fall:
Du hast eine "Schlange". Eine Schlange hat als (private!) Eigenschaften
- eine Farbe
- eine Maximallänge
- eine aktuelle Bewegungsrichtung
- eine geordnete Folge von Punkten, aus denen sie besteht
und hat als (public) Funktionen
- einen Schritt machen
- die aktuelle Bewegungsrichtung ändern
- "sich zeichnen" *
- überprüfen, ob sie mit irgendwas kollidiert ist
*Das Zeichnen ist eigentlich nicht Aufgabe der Schlange, bietet sich hier aber an. Wenn du die Schlange "in ein Bild" malen willst, könnte man stattdessen eine Funktion anbieten, die alle Punkte der Schlange zurückliefert.
In deinem Fall drängt sich da demnach eine Klasse auf...
Code:
class Schlange
{
private Color farbe;
private int maximallLaenge;
private Richtung aktuelleRichtung = Richtung.OBEN; // Siehe letzter Beitrag
private LinkedList<Point> punkte;
public Schlange(Color farbe) {...}
public void macheSchritt() { ... }
public void setzeRichtung(Richtung neueRichtung) {....}
public void zeichneSchlangeAuf(Graphics g) { ... }
// Die Methode kann ein bißchen tricky sein. Überleg' dir was ;-)
public boolean istMitIrgendwasKollidiert() { .... }
}
(ich propagiere zwar englischen Code, aber das ist jetzt erstmal egal)
Dann kannst du dein Hauptprogramm (das Applet) später so so schreiben, dass du leicht mit sowas wie
neue Schlangen hinzfügen kannst. die Schlangen "verwalten sich selbst". Vom Applet aus brauchst du NURNOCH die (wenigen) Methoden aufzurufen, die die Schlangen anbieten. (Die Steuerung der Schlangen würden dann vmlt. Computergegener übernehmen - der obige Code soll nur den prinzipiellen Vorteil einer eigenen Schlangen-Klasse verdeutlichen).
Vielleicht noch eine letzte Frage: Ich suche schon seit längerem ein gutes Tutorial-Buch, das aktuell ist und dich wichtigsten Tipps und Strukturen erläutert. Könntest du mir unter Umständen eines Empfehlen,...
Leider kann ich dir keine Empfehlungen geben, die über die "Java ist auch eine Insel"-Tipps und die Links auf http://www.java-forum.org/de/viewforum.php?f=12 hinausgehen - und WARUM, das hast du hier schon indirekt selbst geschrieben: ...aus dem du deine Erfahrungen geschöpft hast?
"Erfahrungen" kann man nicht "aus irgendwas schöpfen" - man kann sie nur MACHEN :meld: ("Programmieren lernt man nur durch Programmieren" :wink: ) Etwa 90% von dem, was ich schreibe, habe ich mir durch "Learning by doing" angeeignet, und etwa 30% wurden im Grundstudium vermittelt :wink:
Vielen herzlichen Dank für deine Antwort,
zwei Fragen blieben mir auf deine Antwort noch:
Ist
Code:
schlangen.add(new Schlange(Color.red));
das selbe wie
Code:
Schlange NameDerSchlage = new Schlange();
? Oder warum ist schlange klein geschrieben? Kann man auch mit "add" neue Objekte von Klassen erstellen?
Und zweitens:
Die Methode in der Klasse Schlange
Code:
public void zeichneSchlangeAuf(Graphics g) { ... }
kann diese Methode auf das Canvas zeichnen, die ja eine selbsterstellte eigene Klasse darstellt. Ich dachte nur die
paint Methode in der selbsten Klasse wie das Canvas könnte dies? Wenn es geht, wie müsste man es formulieren?
feld.repaint() geht ja nicht.
Vielleicht noch eine letzte Frage: kann man alle Punkte einer ArrayList auf einmal löschen oder braucht man immer
eine Schleife dazu und wie kann man zwei Punkte innerhalb einer ArrayList vergleichen?
(Leider funktioniert die Schleife nicht, die alle Punkte zeichnen soll. Die Klasse "Punkt" gebe es nicht, meint der Kompiler)
Code:
g.drawRect(Punkte.x, Punkte.y, 5, 5);
//can't find symbol varibale x
Nur um dir eine Vorstellung machen zu können, dies wäre das Idealprogramm: Achtung die Kurve
Auch die Steuerung ist bei dieser Version viel besser(Kann Kurven fahren und nicht nur 90° Winkel), aber da hab ich noch gar keine Vorstellung wie ich das anstellen werde.
1.: das hat mit add oder so gar nichts zu tun, das liegt an dem Schlüsselwort new. new erstellt ein neues Objekt und ruft den Konstruktor auf.
Code:
schlangen.add(new Schlange(Color.red));
ist demnach gleichbedeutend mit
Code:
Schlange blup = new Schlange(Color.red);
schlangen.add(blup);
nur dass die erste Methode kürzer ist, leichter zu lesen, und die temporäre Variable entfällt.
2. Es kommt nicht darauf an, in welcher Methode du bist, wenn du zeichnen willst - das wichtige ist, dass du ein Graphics-Objekt hast, das auf das Canvas zeichnet. Dieses Objekt kriegst du entweder als Argument an die paint bzw. update-Methode, oder per getGraphics().
Die Graphics g die du in der paint-Methode hast, kannst du demnach an eine andere Methode weitergeben. So zum Beispiel an die von Marco13 vorgeschlagene
Code:
public void zeichneSchlangeAuf(Graphics g)
3.:
- ArrayList#clear
- Die Klasse heißt Point
- in deinem Code müsste "Punkte" eben eine Objektvariable vom Typ Point sein
- Das steht alles in der API
Das "schlangen" sollte irgendeine Collection sein, die in deiner Hauptklasse rumliegt. Z.B. eine ArrayList. Diese würde dann alle Schlangen enthalten, die es momentan im Programm gibt. Dann kann man sehr leicht (in der Hauptschleife des Threads) alle Schlangen einen Schritt machen lassen, oder in der paint-Methode des MyCanvas alle Schlangen zeichnen lassen.
Code:
ArrayList<Schlange> schlangen = new ArrayList<Schlange>();
...
//... in der Run-methode des Threads
for (Schlange schlange : schlangen)
{
schlange.macheEinenSchritt();
}
...
//in der MyCanvas-Klasse
public void paint(Graphics g)
{
for (Schlange schlange : schlangen)
{
schlange.maleDichAuf(g);
}
}
L-ectron-X hat diesen Beitrag am 18.07.2008 um 15:27 Uhr editiert.
Thema wurde gesperrt, weil dieses Thema von Spambots attakiert wurde.
Zum Freischalten bitte eine PN an mich!
