# Problem beim Aufbau des Spielfelds



## Tomate Level 35 (28. Mai 2015)

Hallo liebe Community.
Ich möchte ein Spiel programmieren basierend auf dem Spiel des Lebens aber mit Fragen um am Ende einen Steckbrief auszugeben. Man soll selbst an einem Rad drehen welches sichtbar ist. So viel mal grob zum Ziel des Ganzen.
Jetzt habe ich aber ein Problem beim Aufbau des Spielfelds:
Es wird zwar alles schön und gut erzeugt jedoch kann man den Spieler ( Kreis ) auf dem Feld nicht sehen.
Ich habe keinen Layoutmanager verwendet, da ich entweder keinen passenden gefunden oder überfordert war (*hust* GridBagLayout *hust*). Der Spieler wird auch erzeugt jedoch ist er immer hinter den Rechtecken, also dem Spielfeld.
Jetzt zu der Frage. Welcher Layoutmanager wäre dafür am hilfreichsten und auch am besten zu verstehen? Und kann ich das vielleicht auch ohne Regeln? Die Codes sind nur auf das grafische beschränkt, da dies momentan meine einzige Baustelle ist . Im Anhang ist noch ein Bild wie das Spielfeld aussieht bzw. aussehen soll.


Mit freundlichen Grüßen 
Tomate 

[JAVA]      

import javax.swing.*;
import java.awt.*;

class SPIEL {
    SPIEL(){
 JFrame fenster= new JFrame("Spiel des Lebens");

        JPanel spieler1= new KreisPanel(Color.BLUE);
        JPanel panel1= new RectPanel(Color.RED);
        JPanel panel2= new RectPanel(Color.BLUE);
        JPanel panel3= new RectPanel(Color.GREEN);
        JPanel panel6= new RectPanel(Color.YELLOW);
        JPanel panel7= new RectPanel(Color.BLACK);
        JPanel panel8= new RectPanel(Color.GREEN);
        JPanel panel9= new RectPanel(Color.RED);
        JPanel panel10= new RectPanel(Color.BLUE);
        JPanel panel12= new RectPanel(Color.GREEN);
        JPanel panel13= new RectPanel(Color.YELLOW);
        JPanel panel14= new RectPanel(Color.BLACK);
        JPanel panel15= new RectPanel(Color.RED);
        JPanel panel16= new RectPanel(Color.WHITE);


        fenster.add(panel1);
        fenster.add(panel2);
        fenster.add(panel3);
        fenster.add(panel6);
        fenster.add(panel7);
        fenster.add(panel8);
        fenster.add(panel9);
        fenster.add(panel10);
        fenster.add(panel12);
        fenster.add(panel13);
        fenster.add(panel14);
        fenster.add(panel15);
        fenster.add(panel16);


        panel1.setVisible(true);
        panel2.setVisible(true);
        panel3.setVisible(true);
        panel6.setVisible(true);
        panel7.setVisible(true);
        panel8.setVisible(true);
        panel9.setVisible(true);
        panel10.setVisible(true);
        panel12.setVisible(true);
        panel13.setVisible(true);
        panel14.setVisible(true);
        panel15.setVisible(true);
        panel16.setVisible(true);



      panel1.setBounds(100,0,200,100);
      panel2.setBounds(300,0,200,100);
      panel3.setBounds(500,0,200,100);
      panel6.setBounds(500,100,200,100);
      panel7.setBounds(100,200,200,100);
      panel8.setBounds(300,200,200,100);
      panel9.setBounds(500,200,200,100);
      panel10.setBounds(100,300,200,100);
      panel12.setBounds(500,300,200,100);
      panel13.setBounds(100,400,200,100);
      panel14.setBounds(300,400,200,100);
      panel15.setBounds(500,400,200,100);

        fenster.add(spieler1);
        spieler1.setVisible(true);
        fenster.setVisible(true);
        fenster.setSize(1000,600);
}
}
[/code]



[JAVA]import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;

import javax.swing.JFrame;
import javax.swing.JPanel;

class RectPanel extends JPanel {
    Color j;
    RectPanel(Color r){
        j=r;
    }
    public void paintComponent(Graphics g) {
        Graphics2D g2d = (Graphics2D) g;
        g2d.setColor(j);
        g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
        g2d.setColor(j);

        Rectangle2D.Double rechteck = new Rectangle2D.Double(0,0,10,100);

        g2d.fill(rechteck);
        g2d.draw(rechteck);
    }
} 
[/code]

[JAVA]import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;

import javax.swing.JFrame;
import javax.swing.JPanel;

class KreisPanel extends JPanel {
  Color c;
  KreisPanel(Color d){
      c=d;
    }
    public void paintComponent(Graphics g) {
        Graphics2D g2d = (Graphics2D) g;
        g2d.setColor(Color.WHITE);
        g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
        g2d.setColor(c);
        int mx = 150;
        int my = 150;
        int r = 100;
        Ellipse2D.Double kreis = new Ellipse2D.Double(150,50,20,20);
        g2d.fill(kreis);
        g2d.draw(kreis);
    }
} 
[/code]


----------



## Tomate Level 35 (29. Mai 2015)

So ich habe nun ein GroupLayout verwendet jedoch immernoch das Problem dass ich die Spieler nciht auf dem Spielfeld angezeigt bekomme.
Irgendwelche Vorschläge dazu?


----------



## Major_Sauce (29. Mai 2015)

Das was du machst ist vollkommen unsinnig.
Tut mir leid, soll jetzt nicht negativ sein, aber wieso machst du für jedes Rechteck ein eigenes Panel ?
Mach doch ne for Schleife oder ähnliches, oder mal einfach in der paintComponent() vom "Hauptpanel" jedes mal ein neues Rectangle.
Danach malst du als letztes den Spiele, der wird dann ganz oben drauf gerendert und feddich,
Da brauchst du dann auch kein Layout...

mfg Major


----------



## Tomate Level 35 (29. Mai 2015)

Ist ja schön und gut wenn das anders einfacher ist jedoch hab ich leider keinen Plan wovon du redest. ( bin grafisch blutiger Anfänger )
Naja das mit ohne Layoutmanager hab ich auch schon probiert aber wie gesagt ich sehe die Spieler dann nicht. Wäre cool wenn du mir zu dem was du geschrieben hast nen Code Posten könntest, dass ich mir was drunter vorstellen kann. Und mit dem GroupLayout geht da garnix vom Verschieben technisch? Ich tue da mittlerweile halt schon ewig rum hab aber noch keine wirklich funktionierende Lösung gefunden. Sorry wenn ich mich gerade ein bisschen doof anstelle aber wie gesagt grafisch bin ich ein Anfänger.
MFG Tomate


----------



## Major_Sauce (29. Mai 2015)

Folgender maßen: 

Du hast oben die Zeile code:


```
g2d.fillRect(0, 0, this.getWidth(), this.getHeight());
```

Da könntest du ja sowas draus machen:


```
int x = 0;
        int y = 0;

        g2d.fillRect(x, y, x + 64, y + 64);
```

Nun würde der bei ner x-y-Koordinate anfangen und nen Rechteck mit der Größe von 64x64 malen.
Das noch in ne Schleife und die Farbe änder:


```
for(int x = 0; x < 8; x++){
                for(int y = 0; y < 8; y++){
                        g.setColor(/*irgend ne Farbe*/);
                        g.fillRect(x * 64, y * 64, 64, 64);
                }
        }
```

Dadurch hast du ein 8x8 Feld mit verschiedenen farben...

mfg Major


----------



## Tomate Level 35 (30. Mai 2015)

Und das ist dann alles in einem Panel und wenn ich die Spieler adde sind sie drüber?
Aber haben bei der for-Schleife dann nicht alle die gleiche Farbe? 
Und kann ich deinen Code theoretisch 1:1 übernehmen?
Wenn ja dann danke schonmal im Vorraus 
MFG Tomate


----------



## Major_Sauce (30. Mai 2015)

Hey, 1:1 wird nicht reichen...
Die farben musst du jedes mal Ändern.
Wenn du dem Spieler ein neues Panel gibst ist er drüber, es ist aber besser die Spieler auch einfach ohne Panel zu machen, d.h. du machst das gleiche wie bei den Feldern nur eben mit nem Bild oder so und malst sie einfach nach dem du die felder gemalt hast.

mfg Major


----------



## Tomate Level 35 (30. Mai 2015)

Ich hab aber eben das RectPanel und das KreisPanel, wo jeweils der Spieler bzw das Spielfeld dann implementiert wird. Soll ich dass dann in eine Klasse zusammenfügen?
Weil anders kann ich mir nicht vorstellen dass ich das zusammen auf ein Panel bekomme
Kann ich die Rechtecke bzw. Spieler dann auch besonders ansprechen, z.B Spieler eins bewege dich oder Feld 3 werde rot oder geht dass dann nichtmehr wenn ich das so mache wie du gesagt hast. Weil die haben dann ja keinen besonderen Namen oder täusche ich mich da?
.
MFG Tomate


----------



## Major_Sauce (30. Mai 2015)

Folgender Maßen:


```
for(int x = 0; x < 8; x++){
                for(int y = 0; y < 8; y++){
                        g.setColor(/*irgend ne Farbe*/);
                        g.fillRect(x * 64, y * 64, 64, 64);
                }
        }
```

jetzt kannst du natürlich einfach dahinter nun noch die Spieler rendern:


```
xPlayer = 3;
        yPlayer = 4;

        for(int x = 0; x < 8; x++){
                for(int y = 0; y < 8; y++){
                        g.setColor(/*irgend ne Farbe*/);
                        g.fillRect(x * 64, y * 64, 64, 64);
                }
        }

        //Render player
        g.setColor(Color.GREEN);
        g.fillRect(xPlayer * 64 + 10, yPlayer * 64 + 10, 46, 46);
```

nun kannste auch nen Spieler drüber malen...

mfg Major


----------



## Tomate Level 35 (30. Mai 2015)

Das mit dem Spieler drubermalen ist mir bewusst aber ich muss den ja dann auch bewegen können. Kann ich den jeweiligen Spieler dann konkret ansprechen oder nicht?


----------



## Major_Sauce (30. Mai 2015)

Öhm ja, einfach blos die xPlayer und yPlayer vergrößern oder verkleinern...


----------



## Tomate Level 35 (30. Mai 2015)

Ich meine wenn die Methode fertig ist dann hab ich ja mein Spielfeld und die Spieler. Die Spieler muss ich dann mithilfe einer Methode bewegen können. XPlayer und YPlayer sind aber doch lediglich temporäre ints. Ich steh grade wahrscheinlich extrem auf dem Schlauch. Kannst du kurz nen Code für ne Methode Posten, wie du das meinst ? Wäre echt geil von dir.
MFG Tomate


----------



## Tomate Level 35 (30. Mai 2015)

iChat jetzt ne Möglichkeit gefunden jedoch habe ich jetzt das Problem, dass bei repaint() nichts passiert. Also wenn ich den Spieler direkt im Konstruktur der Spielfeldaufbauklasse bewege funktioniert alles wunderbar. Wenn ich jedoch die Methode in meiner eigentlichen Spielmethode aufrufe und dann Fenster.repaint() sage passiert nix. Woran kann das denn nun schon wieder liegen?


----------



## Major_Sauce (30. Mai 2015)

Könnten Fehler drin sein, schreibe das gerade hier direkt im Forum:


```
public class Player {
    
        private int x;
        private int 
        private Color color;

        public Player(Color color){
                x = 0;
                y = 0;
                this.color = color;
        }

        public void move(int x, int y){
                this.x += x;
                this.y += y;
        }

        public void render(Graphics2D g){
                g.setColor(color);
                g.drawRect(x * 64 + 10, y * 64 + 10, 44, 44);
        }

}

public class Spielfeld extends JPanel {

        private int width;
        private int height;

        private Player player1;
        private Player player2;

        public Spielfeld(int width, int height){
                this.width = width;
                this.height = height;
                player1 = new Player(Color.GREEN);
                player2 = new Player(Color.RED);
        }

        public void render(Graphics2D g){
                for(int  x = 0; x < width; x++){
                        for(int y = 0; y < height; y++){
                                //Hier noch iwie die Farbe von g ändern
                                //g.setColor(Color.BLUE);
                                g.drawRect(x * 64, y * 64, 64, 64);
                        }
                }
                player1.render(g);
                player2.render(g);
        }

        protected void paintComponent(Graphics graphics){
                Graphics2D g = (Graphics2D)graphics;
                render(g);
        }

}
```

sollte normalerweise funktionieren...

mfg Major


----------



## Tomate Level 35 (31. Mai 2015)

Muss ich dann nicht noch die alte Spielerfigur löschen? Wenn ja gibt's ne Methode um ne Farbe in der Umgebung herauszufinden? Aber ansonsten hab ich das Prinzip glaub ich verstanden. Muss ich halt mal ausprobieren  
Danke schonmal für den Fall das es hilft wenns nicht geht melde ich mich nochmal.
MfG Tomate


----------



## Major_Sauce (31. Mai 2015)

Die alte musst du löschen.
Da müsste jetzt normalerweise alles dabei sein.
Das mit der Methode musst du dir selbst zusammebasteln. Zum Bleistift die farben mit Koordinaten in ner Liste speichern ?!

mfg Major


----------



## Tomate Level 35 (1. Jun 2015)

Wenn ich so eine Methode, wo Graphics2D oder ähnliches als Parameter drinnen steht, aufrufe, was soll ich da dann reinschreiben?
Ich hab jetzt nämlich in meinem normalen Spiel die Methode spielerBewegen() drinnen die den Spieler nach int unterscheidet und dann den demenstprechenden bewegt jedoch muss ich ja ein Graphics2D Objekt übergeben und uch weiß nicht was ich da reinschreiben soll.
Ist vielleicht ne dumme Frage aber ich hab da gerade echt Probleme damit xD

das ist in meinem Spielfeldaufbau:

```
void spielerBewegen(int a , Graphics2D g){

        if ( a==0){
            g.clearRect(player1.gibX(),player1.gibY(),20,20);
            player1.move(200,0);
            render(g);
        }
        if( a==1){
             g.clearRect(player2.gibX(),player2.gibY(),20,20);
            player2.move(200,0);
            render(g);
        }

    }
```
Das im Spieler:

```
public void render(Graphics2D g){
        
     
        g.setColor(spielerfarbe);
        g.fillOval(x , y , 20, 20);
    }
```
Und das im eigentlichen Spiel:

```
void bewegen(Graphics2D g){
        g= (Graphics2D) g;
        Feld.spielerBewegen(aktuellerSpieler,g);
    }
```
Ach ja und wenn ich meine bewegen Methode aufrufe kommt ne nullpointer exception wenn ich das Graphics2D mit null mache. Aber ich glaube das liegt daran.
MFG Tomate


----------



## Tomate Level 35 (1. Jun 2015)

Ach ja und was bedeutet das += in deinem Code da oben. Ich hab einfach ein  x = x+xn draus gemacht. Also aus dem this.x+=x
Naja wäre cool wenn du mir die Fragen alle beantworten könntest .


----------



## Major_Sauce (1. Jun 2015)

Du hast Post !
also ne PN...


----------

