Hallo

Ich muss mit Java 2D ein Spielfeld zeichnen. Es besteht aus lauter Quadraten, welche alle rot sind. Auf dem Spielfeld ist links oben in der Ecke ein schwarzes Quadrat. Nun möchte ich dieses Quadrat mit meiner Tastatur auf dem Spielfeld bewegen können. Zunächst einmal die Klasse in der das Feld gezeichnet wird.

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

public class Field extends JPanel {       /**      * Saves which Rect is currently black.      */             private Point currentRect = new Point(0, 0);         /**      * Color of the drawn rect;      */     private Color currentRectColor = Color.BLACK;       /**      * Constructor.      *      */     public Field() {         this.setVisible(true);         this.repaint();     }       @Override     protected void paintComponent(final Graphics g) {         super.paintComponent(g);         Graphics2D twoD = (Graphics2D) g;         // Backgorund color used as border color.         this.setBackground(Color.BLACK);                                   for (int x = 0; x < MainFrame.RECNUMBER; ++x) {             // draws the ful squares             for (int y = 0; y < MainFrame.RECNUMBER; ++y) {                 if (x == currentRect.getX() && y == currentRect.getY()) {                     twoD.setColor(currentRectColor);                 }                                                   else {  twoD.setColor(Color.RED);                 }                 twoD.fillRect(x * MainFrame.RECSIZE + x,                         y * MainFrame.RECSIZE + y, MainFrame.RECSIZE,                         MainFrame.RECSIZE);             }         }     } }

Mein Ansatz war jetzt irgendwie bei "private Point currentRect = new Point(0, 0);" (Zeile 8)
immer die neuen Koordinaten die durch das drücken der Tastatur entstehen, dort hinein zu schreiben. Sodass das schwarze Quadrat dann immer an der neuen Stelle gezeichnet wird. Kann mir jemand sagen wie ich dass mache?

Hier der Code mit dem Keylistener

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

public class Controller implements ActionListener, KeyListener {         private Field field ;       public Controller( Field field ) {         this.field = field;         this.field.addKeyListener( this );     }                          public final void up() {                   }               @Override     public final void keyPressed(final KeyEvent e) {           int code = e.getKeyCode();               if (code == KeyEvent.VK_W) {               up();         }     }       @Override     public void actionPerformed(ActionEvent e) {             }       @Override     public void keyTyped(KeyEvent e) {             }       @Override     public void keyReleased(KeyEvent e) {     } }

Der ist natürlich noch unvollständig. Ich hoffe da blickt jemand durch. Bin absoluter Anfänger in Java-Programmierung. Wär echt nett wenn mir jemand helfen könnte

schöne Grüße

Davon abgesehen das es bei uns im Java-Forum zum guten Ton gehört [java][/java] - Tags zu verwenden sieht das ganze ziemlich schwammig aus.

Warum erzeugst du ein Objekt der Klasse Controller und setzt in diesem den ActionListener anstatt einfach in der Klasse Field ein

Code java:

1	addActionListener(new Controller(this));

zu verwenden ?

Auch ist es sehr merkwürdig das du in einer von JPanel abgeleiteten Klasse im Konstruktor

Code java:

1 2	setVisible(true); repaint();

aufrufst. Das ist weder OOP noch ergibt das irgendeinen Sinn. Davon abgesehen das THIS hier überhaupt nicht notwendig ist.

Ansonsten sieht das halbwegs verwendbar aus.
Was jetzt noch fehlt ist ein field.update(field.getGraphics()) in der Methode Controller.up();

Nur mal so als Frage : wie viel Erfahrung hast du bereits mit Java und warum "Ich muss" ?

Als Grundlage würde ich dir die JavaInsel *einfach mal GooGLe fragen* empfehlen. Da werden auch solche Sachen wie Listener und OOP behandelt.

Code bekommst du von mir bewusst NICHT da du von mir gerade alle Informationen bekommen hast die du brauchst um das was du vorhast umzusetzen.

Wenn du zu irgendetwas konkrete Fragen hast ... dann helfen wir dir gerne ... aber einfach : "ich muss das und das machen ... HILFE" ... dafür sind wir hier nicht zuständig.
Auch fehlt eine Beschreibung des Problems WAS nicht funktioniert oder WOBEI du konkrete Hilfe brauchst.

btw : dein Beispiel ist so leider nicht compilerbar. Auch das sollte man beachten : ein kurzes , compilebares Beispiel an dem das Problem deutlich wird welches man *hoffentlich* ausführlich beschrieben hat.

Zitat von celtx

Ich muss mit Java 2D ein Spielfeld zeichnen. Es besteht aus lauter Quadraten, welche alle rot sind. Auf dem Spielfeld ist links oben in der Ecke ein schwarzes Quadrat. Nun möchte ich dieses Quadrat mit meiner Tastatur auf dem Spielfeld bewegen können.

Die Frage ist, wie liegen die roten Quadrate und darf das schwarze Quadrat über die roten Quadrate zu liegen kommen? Je nachdem, brauchst Du ein Modell des Spielfelds, mit dem geprüft werden kann, ob das schwarze Quadrat überhaupt in eine bestimmt Richtung bewegt werden kann.

Zitat von SPiKEe

Wenn du zu irgendetwas konkrete Fragen hast ... dann helfen wir dir gerne ... aber einfach : "ich muss das und das machen ... HILFE" ... dafür sind wir hier nicht zuständig.
Auch fehlt eine Beschreibung des Problems WAS nicht funktioniert oder WOBEI du konkrete Hilfe brauchst.

Okei dann versuche ich mal mein Problem zu konkretisieren.

Bei

Code java:

1 2 3 4 5 6 7 8 9 10 11

@Override     public final void keyPressed(final KeyEvent e) {           int code = e.getKeyCode();               if (code == KeyEvent.VK_W) {               up();         }     }

soll, wenn die Taste W gedrück wird, an die Methode up() ein Wert übergeben werden. Ich dachte mir am besten wäre vielleicht ein Integer, welcher dann, jedes mal wenn die Taste W gedrückt wird hochzählt. Dieser Wert soll dann in der Klasse Field an der Stelle

Code java:

1	private Point currentRect = new Point(0, 0);

übergeben werden. Der Punkt soll dann durch den neuen Wert neu beschrieben werden, sodass dann hier

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

@Override     protected void paintComponent(final Graphics g) {         super.paintComponent(g);         Graphics2D twoD = (Graphics2D) g;         // Backgorund color used as border color.         this.setBackground(Color.BLACK);                                   for (int x = 0; x < MainFrame.RECNUMBER; ++x) {             // draws the ful squares             for (int y = 0; y < MainFrame.RECNUMBER; ++y) {                 if (x == currentRect.getX() && y == currentRect.getY()) {                     twoD.setColor(currentRectColor);                 }                                                   else {  twoD.setColor(Color.RED);                 }                 twoD.fillRect(x * MainFrame.RECSIZE + x,                         y * MainFrame.RECSIZE + y, MainFrame.RECSIZE,                         MainFrame.RECSIZE);             }         }

das schwarze Quadrat an der neuen Stelle gezeichnet werden kann.

Ich habe schon probiert in die up() Methode einen Integer zu schreiben der dann hochzählt. Meine frage wäre jetzt wie kann ich diesen Wert dann an meine Field Klasse übergeben? und funktioniert das überhaupt so?

Zitat von SPiKEe

btw : dein Beispiel ist so leider nicht compilerbar. Auch das sollte man beachten : ein kurzes , compilebares Beispiel an dem das Problem deutlich wird welches man *hoffentlich* ausführlich beschrieben hat.

Hier ist noch meine Startup und meine MainFrame-Klasse. Damit müsste das Programm dann complierbar sein.

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public final class StartUp {       /**      * Verhindert Instanziierung dieser Klasse.      */     private StartUp() {       }       /**      * Einstieg in das Programm.      *      * @param args      *            Kommandozeilenargumente      */     public static void main(final String[] args) {           new MainFrame();     } }

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

public class MainFrame extends JFrame {       /**      * Number of rectangles.      */     public static final int RECNUMBER = 15;     /**      * Size of the single rectangels.      */     public static final int RECSIZE = 50;       /**      * Constructor.      */     public MainFrame() {         init();     }       /**      * Inits the frame.      */     private void init() {         final Field field = new Field();         this.add(field);         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);         this.setTitle("Java2D");         this.pack();         this.setResizable(false);         this.setVisible(true);         this.setSize(new Dimension(                 RECNUMBER * RECSIZE + this.getInsets().left                 + this.getInsets().right + RECNUMBER - 1,                 RECNUMBER * RECSIZE + this.getInsets().top                 + this.getInsets().bottom + RECNUMBER - 1));     } }

schöne Güße
celtx

Hi,

also um dein schwarzes Feld zu bewegen, kannst du die x- und y-Position des Feldes einfach immer mit dem Faktor (Länge bzw. Höhe der Felder) multiplizieren. Dann ist dein Feld da wo es hin soll.

Gruß

Fabio

Selbst wenn Du an die Instanz von Field rankommst, was willst Du damit machen? Alle Felder sind privat und es gibt auch keine Setter.

Zitat von Fabio Hellmann

also um dein schwarzes Feld zu bewegen, kannst du die x- und y-Position des Feldes einfach immer mit dem Faktor (Länge bzw. Höhe der Felder) multiplizieren. Dann ist dein Feld da wo es hin soll.

Das besetzt Feld müsste noch auf rot. Wo wird das gemacht?

@suchong
Es gibt hier bei uns eine EDIT-Funktion mit der du deine Posts nach belieben editieren kannst.

Ich habe mal eine Zusammenführung deiner Posts beantragt.

@Grünschnabel
Irgendwie kann ich dir nicht so ganz folgen. Es geht mir hier hauptsächlich um die Klasse Controller. Hier soll mit Hilfe des Keylisteners, durch ein Key-Event eine Variable verändert werden, welche dann in die Klasse Field geschrieben werden soll.
Ich habe inzwischen den Controller soweit verändert. Aber irgendetwas muss hier noch falsch sein. Denn die variable m verändert sich nicht durch drücken der W-Taste.
Hier ist der angepasste Controller:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

public class Controller implements ActionListener, KeyListener {       public static int m = 3;                           private Field field ;       public Controller( Field field ) {         this.field = field;         this.field.addKeyListener( this );     }                                         @Override     public final void keyTyped(final KeyEvent e) {           int code = e.getKeyCode();               if (code == KeyEvent.VK_W) {                up();                                                         }                     }                       public static void up(){                   Controller.msetter();                       }                                        public static void msetter (){            m++;                       }                 @Override     public void actionPerformed(ActionEvent e) {     }       @Override     public void keyPressed(KeyEvent e) {             }         @Override     public void keyReleased(KeyEvent e) {     }             }

Wie ich es oben bereits schon erwähnte hast du scheinbar keine Ahnung von OOP.
Und genau das ist hier das Problem.

Da sowohl die Variable "m" static , die Setter-Methode *im übrigen nicht gerade ein Name der den Konventionen folgt , von der Signatur ganz zu schweigen* static sowie der Call selbst static sind ... arbeitest du nicht mit einer Instanz-Variable *wie du es warscheinlich willst* sondern nur mit einer Konstanten.

Ich würde dir dann doch noch mal einen Blick in die JavaInsel empfehlen ... und GooGLe mal nach "java oop" ... da dürftest du dann im Sun-Tutorial einiges lernen.

Ich persönlich habe gerade nur sehr wenig bis überhaupt keine Lust dir OOP an diesem Beispiel zu erklären.

Zitat von suchong

Selbst wenn Du an die Instanz von Field rankommst, was willst Du damit machen? Alle Felder sind privat und es gibt auch keine Setter.

Also ich meinte das auch nicht so, dass ich direkt auf die Variablen x und y zugreifen kann. Sondern eher in der Form:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public class Moveable {    private static final int SPEED_X = 2;    private static final int SPEED_Y = 2;    private int x;    private int y;      public Moveable(int x, int y) {       this.x = x;       this.y = y;    }      public void moveUp() {       y -= SPEED_Y;    }      public void moveDown() {       y += SPEED_Y;    }      public void moveRight() {       x += SPEED_X;    }      public void moveLeft() {       x -= SPEED_X;    } }

Dann muss man natürlich noch die X- und Y-Koordinaten via getter abfragen können.

Zitat von Fabio Hellmann

Also ich meinte das auch nicht so, dass ich direkt auf die Variablen x und y zugreifen kann. Sondern eher in der Form:

Die Frage war auch nicht an Dich gerichtet. Ich finde das Klassendesign sehr misslungen und die Implementierung der Klassen noch übler. Damit verabschiede ich mich aus diesem Strang.

@ suchong
und tschüss!

Müsst ihr euch jetzt schon gegenseitig nerven nur weil einer das Interesse an einem Thread verliert weil der Thread-Ersteller noch *scheinbar* sehr unerfahren ist ?

Das ist irgendwie ... witzig.

Wobei ich mich auch der Meinung anschließen muss : Design und Implementierung sind ziemlich schlecht.
Vielleicht solltest du dir mal ein Blatt Papier und einen Bleistift nehmen und dir erstmal Gedanken machen wie das ganz über logisch funktionieren soll / kann. Über eine konkrete Implementierung kann man sich dann immer noch den Kopf zerbrechen *wobei mir auf anhieb so einiges einfallen würde das "Problem" in ein paar Minuten zu lösen*.

Falls es dir nicht zu viel ist kannst du dir ja mal mein Schiffe-Versenken angucken *siehe Signatur* *das sollte ich eigentlich auch langsam mal fertig machen* ... es ist zwar auch nicht das beste OOP .. aber man erkennt deutlich die Manipulationsstrukturen ...

Zitat von SPiKEe

Wobei ich mich auch der Meinung anschließen muss : Design und Implementierung sind ziemlich schlecht.
Vielleicht solltest du dir mal ein Blatt Papier und einen Bleistift nehmen und dir erstmal Gedanken machen wie das ganz über logisch funktionieren soll / kann. Über eine konkrete Implementierung kann man sich dann immer noch den Kopf zerbrechen

Ob das Design oder die Implementierung ziemlich schlecht ist soll mir recht sein, wenn das programm denn einfach mal nur funktionieren würde. Den Code habe ich, bis auf den Controller übernommen.

Zitat von SPiKEe

*wobei mir auf anhieb so einiges einfallen würde das "Problem" in ein paar Minuten zu lösen*.

Warum sagst du es mir dann nicht.Zu sagen ich kenn die Lösung aber sie nicht zu posten. hmm... ich weis nicht!

Zitat von SPiKEe

Ich würde dir dann doch noch mal einen Blick in die JavaInsel empfehlen ... und GooGLe mal nach "java oop" ... da dürftest du dann im Sun-Tutorial einiges lernen.

Und mich auf google und dergleichen zu verweisen ...naja...meinst du nicht dass ich das schon probiert habe....desswegen schreibe ich doch hier. Wenn ich nicht wollen würde das man mir hier hilft würde ich auch nicht hier schreiben.

Ok ... ich fass es mal ganz kurz zusammen :

Du hast eine GUI und willst das sich auf Tastendruck etwas daran ändert.

Das ist doch ganz grob gesagt das was du willst , oder ?

Was du also brauchst sind folgende Dinge :

1) Die GUI selbst
2) Das , WAS sich nachher bewegen soll ...
3) Einen KeyListener der auf den Tastendruck reagiert

Ok ... geh ich das ganze mal Schritt für schritt durch.

Als GUI nehmen wir mal ein 10x10 Raster an *für Code sieh bitte in meinem Blog nach da ich nicht wirklich Lust habe bereits gepostetes noch mal zu posten obwohl ich dich bereits auf entsprechende Stelle verwiesen habe*. Das macht 100 Felder. Jedes dieser Felder müssen wir einzeln DIREKT ansprechen können. Das machen wir entweder mit einem 2D-Array oder einer 1D-Liste und geben jedem Feld bei erzeugung einen Identifier mit *ich persönlich würde hier das 2D-Array nehmen*.

Als nächstes erzeugen wir unsere Felder. Diese brauchen *im groben ohne zu sehr ins Detail zu gehen* nur ein Flag ob sich das zu bewegende Objekt gerade auf ihnen befindet oder nicht. Demzufolge ist die Klasse für die Felder sehr einfach aufgebaut.
Da man Variablen möglichst verborgen halten soll nennen wir dieses Flag also

Code java:

1	private boolean flag=false;

Dann noch eine Setter- und eine Getter-Methode ... hierbei ist auf Grund des Datentyps boolean auf den Namen der Getter-Methode zu achten : laut Konventionen werden Getter welche bool-Flags returnen nicht "getXXX" genannt sondern "isXXX" :

Code java:

1 2	public void setFlag(boolean flag) { this.flag=flag; } public boolean isFlag() { return flag; }

Um jetzt HIER gleich das re-Rendern zu verlassen erweitern wir die Setter Methode noch wie folgt

Code java:

1 2 3 4 5

public void setFlag() {     this.flag=flag;     update(getGraphics()); }

Wobei darauf zu achten ist das die Feld-Klasse von z.B. JPanel oder vergleichbarem erbt.

Nun fügen wir dem Container *also in deinem Fall einem JFrame* noch einen KeyListener hinzu.
Auch ich würde hier das Design mit 2 Klassen bevorzugen. Es hält den ganzen Code deutlich übersichtlicher.
Im KeyListener implementieren wird jetzt die Tasten auf die wir reagieren wollen , also z.B. WASD und lassen dann über einen Thread die entsprechenden Methoden up() left() down() righ() aufrufen.

Jedoch verwende ich KEINEN Counter wie du ... sondern arbeite direkt mit dem Array.
Jeder dieser Methoden ruft eine Setter-Methode im JFrame *dort wo auch das Array liegt* auf dem wir einen Steuerparameter *bei 4 Möglichkeiten reicht Byte als Bit-Maske aus* mitgeben.
Diese Setter-Methode geht jetzt durch das Array und sucht erstmal mit Feld.isFlag() nach der aktuellen Position des zu bewegenden Objektes , wertet die Schleifen-Counter aus und entscheidet ob die gewünschte Bewegung gültig ist. Wenn FALSE , dann wird einfach returned und es passiert nichts. Wenn TRUE wird im alten Feld mit setFlag(false) die Auswahl aufgehoben und *in Abhängigkeit zur Steuer-Bit-Maske* X oder Y um eins erhöt oder verringert und schlussendlich im "neuen" Feld mit setFlag(true) das Flag gesetzt.

Das wäre eine halbwegs vernünftige OOP-Struktur nach der du dich versuchen kannst zu richten.
Auch hier poste ich dir wieder bewusst keinen Code da ich dich ja erstmal selbst denken lassen und auf KONKRETE FRAGEN warten will.
Wenn du z.B. bei den Referenzierungen der Felder Probleme hast ... dann kann man da speziell helfen ... aber deine Aufgabe wird dir hier so einfach keiner abnehmen.