Tetris Probleme bei Klassen

[Java xyrse123]

Hallo,
für mein Tetris Spiel habe ich 3 Klassen. In der Klasse Stein werden die Koordinaten und die Farben von den Steinen gespeichert und die Steine werden rotiert. Die Klasse SpielFeld stellt das Spiel als ein Integer Array dar und die Klasse Tetris ist für die Grafik und Steuerung.
Das Spielfeld was mir ausgegeben wird, besteht nur aus Nullen, es wurde also kein Stein gesetzt. Könnte mir wer einen Tipp geben woran das liegt?
Schonmal Danke im vorraus.

public class Stein {      
   
    int farbcode;   
    int x1, y1; int x2,y2;   
    int x3,y3; int x4,y4;
          
    public Stein(int f) {       
       
        switch(f) { // Quadrat wird als 11
        case 1:                                  11 gespeichert
        x1=0; y1=7; x2=0; y2=8;
        x3=1; y3=7; x4=1; y4=8;
        farbcode=1;       
        break;
                 
        }               
    }


public class SpielFeld {

    final  int höhe=30;
    final   int breite=16;   
    
 int SpielFeld[][]=new int[16][20];    
       Stein SpielStein = new Stein((int)Math.random()*6+1); // zufälliger Stein

public void setzeStein(Stein SpielStein) {
        SpielFeld[SpielStein.x1][SpielStein.y1] = SpielStein.farbcode;
        SpielFeld[SpielStein.x2][SpielStein.y2] = SpielStein.farbcode;
        SpielFeld[SpielStein.x3][SpielStein.y3] = SpielStein.farbcode;
        SpielFeld[SpielStein.x4][SpielStein.y4] = SpielStein.farbcode;
        System.out.println(SpielStein.farbcode);           
}
public void gebeFeldaus(int SpielFeld[][]) {
        for(int i=0; i<30; i++) {
            for(int j=0; j<16; j++) {
                System.out.print(SpielFeld[i][j]);
            }
        System.out.println();
        }
    }
}


public class Tetris extends JFrame  {
       
   Stein SpielStein=new Stein((int)Math.random()*6+1);
   
   SpielFeld f = new SpielFeld(); 
   int SpielFeld[][]=new int[16][30];
    
    Tetris() {
       
        f.setzeStein(SpielStein);     
        f.gebeFeldaus(SpielFeld);
    }
}

 

[MoxxiManagarm]

Du gibst das Spielfeld-Array aus der Klasse Tetris aus, den SpielStein setzt du aber in das SpielFeld-Array von der Klasse SpielFeld

 

[Java xyrse123]

OK,danke ich war gestern Abend wohl zu müde, jetzt funktioniert es.

 

[Java xyrse123]

Wie kann ich das Array aus der SpielFeld Klasse in der Tetris Klasse benutzen ? Muss ich es erst kopieren?

 

[VfL_Freak]

Moin,

Wie kann ich das Array aus der SpielFeld Klasse in der Tetris Klasse benutzen ?

bau Dir in 'Spielfeld' eine getArray-Funktion!
VG Klaus

 

[MoxxiManagarm]

public void gebeFeldaus(int SpielFeld[][]) {
        for(int i=0; i<30; i++) {
            for(int j=0; j<16; j++) {
                System.out.print(SpielFeld[i][j]);
            }
        System.out.println();
        }
    }
}

Ich hoffe du hast bei der Korrektur auch gemerkt, dass höhe und breite der SpielFeld Klasse bei dir aktuell keine Verwendung finden. Die Schleifengrenzen werden hier leicht zu Fehler führen.

 

[Java xyrse123]

Ich hoffe du hast bei der Korrektur auch gemerkt, dass höhe und breite der SpielFeld Klasse bei dir aktuell keine Verwendung finden. Die Schleifengrenzen werden hier leicht zu Fehler führen.

Ja, ich habe es geändert.

Ein Problem gibt es noch. Der Stein fällt jetzt durch einen Timer gesteuert runter, er lässt sich durch die Tasten steuern und bleibt auf dem Boden stehen. Aber wenn ich dann einen neuen Stein einsetze, wird der Stein nur in dem Array gesetzt und nicht auf dem Bildschirm.

class Animation extends TimerTask {  
        @Override
        public void run() {
            SpielFeld.nachUnten(SpielStein);    // Stein fällt, hier wollte ich einen neuen Stein einsetzen                                      
                repaint();           
        }       
    }

class TetrisPanel extends JPanel  {              
        
TetrisPanel() {
            setPreferredSize(new Dimension(160,300));
            setBackground(Color.PINK);                                                                             
        }                   
        public void paint(Graphics g) { // Hier wird der SpielStein gemalt
            int spielfeld[][]= SpielFeld.getSpielFeld(); // SpielFeld aus SpielFeld Klasse bekommen
           
            super.paint(g);                             
            for (int a = 0; a < höhe; a++) {
                for (int b = 0; b < breite; b++) {
                    if (spielfeld[a][b] == SpielStein.farbcode) {                    
                        g.setColor(farbcodezuFarbe(SpielStein, g));
                        g.fillRect(b*10 , a*10 , 10, 10);
                    }
                }
            }   
        }             
    }

Das kommt wahrscheinlich weil in der Animation Klasse keine paint() Methode ist, aber ich kann sie dort auch nicht überschreiben.

 

[Java xyrse123]

Ich habe mir jetzt eine Methode gemacht die einen zufälligen SpielStein bestimmt, aber mir ist noch nicht ganz klar wie ich in dem Timer immer neue SpielSteine erstelle.

ArrayList<Stein> SteinListe = new ArrayList<Stein>();
public Stein zufälligerStein() {
            SteinListe.add(new Stein(1));
            ...                                       // alle 7 Steine
            SteinListe.add(new Stein(7));  
          
            random = new Random();
            int index = random.nextInt(SteinListe.size());
            Stein stein = SteinListe.get(index);                              
                                          
            return stein;          
        }

 

[MoxxiManagarm]

Mit dem Code wirst du aber jedes mal, wenn du einen zufälligen Stein willst 7 Steine in die SteinListe ergänzen. Auch scheint Random bei dir global zu sein, dann reicht es auch, wenn du Random einmal definierst.

public Stein zufälligerStein() {
  return new Stein(random.nextInt(7) + 1);
}

Du hast doch einen Timer, der Steine nach unten bewegt. Immer dann, wenn ein Stein angekommen ist, also nicht mehr nach unten wandern kann, dann generierst du einen neuen Stein. Deine Methode nachUnten() könnte dafür z.B. einen boolean zurückgeben, der aussagt ob der Stein nach unten bewegt werden konnte oder nicht. Falls nicht, dann erstelle einen neuen.

if(! SpielFeld.nachUnten(SpielStein)) SpielStein = zufälligerStein();

 

[Java xyrse123]

Ich habe mich jetzt nochmal an Tetris versucht. Es werden jetzt zwar immer neue zufällige Steine erzeugt, aber wenn ein Stein unten ankommt verschwindet er sofort wieder.
Hat wer einen Tipp wie ich den Stein fest an eine Stelle zeichne, wenn er unten angekommen ist und dann erst einen neuen Spielstein erzeuge?

 

[MoxxiManagarm]

Oben zeichnest du ja nur den bewegten Stein neu. Hast du denn mittlerweile eine Liste stehender Steine? Du musst du verwalten und auch neuzeichnen.

 

[Java xyrse123]

Hast du denn mittlerweile eine Liste stehender Steine?

Was genau meinst du damit?

 

[MoxxiManagarm]

Naja wenn ein Stein unten ankommt löst er sich ja nicht in Luft auf. Du brauchst eine Datenstruktur für diese Steine. Abgesehen vom Zeichnen dieser Steine willst du ja auch Steine nach unten rücken wenn eine Zeile voll ist und damit verschwindet

 

[Java xyrse123]

Dann speichere ich die heruntergefallen Steine in einer Liste.
Aber ich verstehe immer noch nicht wirklich warum der untere Stein verschwindet, wenn oben ein neuer Stein eingesetzt wird.

 

[Java xyrse123]

Ich habe es jetzt nochmal mit einer Liste probiert, oben wird ein Stein angezeigt aber er fällt nicht runter.
In der Konsole lasse ich mir die Koordinaten von dem aktuellen SpielStein anzeigen und dort sieht es so aus als würde sich der Stein bewegen, nur auf dem Panel eben nicht.
Warum fallen die Steine nicht runter?

ArrayList<Stein> SteinListe = new ArrayList<Stein>();

                public void run() {
                
                    if(SteinListe.isEmpty()) {
                        SteinListe.add(neuerStein());
                    }
                
                    SpielFeld.nachUnten(aktuellerStein());                                                                                          
                    if(SpielFeld.nachUntenverschiebar(aktuellerStein())==false) {                                                                                                                                                                           
                              SteinListe.add(neuerStein());                                            
                          }                
                    repaint();        
                }
                };
                timer.schedule(task,0, 200);                                
        }
            
        public Stein neuerStein() {
            Stein s = new Stein(random.nextInt(7) + 1);
            return s;
        }
    
        public Stein aktuellerStein() {
            return SteinListe.get(SteinListe.size()-1);
        }