Clear Canvas und anschließendes neues Erstellen von Objekten auf Canvas aus ArrayList

wolfin96

Mitglied
Hallo miteinander! Bei meinem Programm werden auf der Oberfläche in einem Canvas Rechtecke gezeichnet. Diese Rechtecke werden wie ein Stapel übereinander angezeigt. Die Daten zu jedem einzelnen Rechteck (xStartpunk, yStartpunk, breite, bezeichnung) werden in einem Objekt (RechteckDaten) gespeichert und dieses Objekt wird dann der Reihenfolge nach in einer ArrayList gespeichert. Nun bin ich gerade dabei eine Methode zu schreiben, die immer das oberste Rechteck entfernen soll. Dazu wird in der Methode zum entfernen zuerst das letzte Objekt aus der ArrayList gelöscht. Dann wird der ganze Canvas geleert und danach soll mit einer for-Schleife die ArrayList abgegangen werden um wieder das Canvas mit den verbliebenen Dreiecken zu füllen. Generell funktioniert das auch, die Objekte werden entsprechend in der ArrayList gespeichert und das letzte Objekt wird auch gelöscht. Nur scheint in der for-Schleife oder in der Methode die die Rechtecke zeichnet ein Problem zu sein, da nämlich nach dem Entfernen immer nur jedes zweite Rechteckt wieder dargestellt wird. Hier mal ein Beispiel:
- vorher vier Rechtecke, Objekte haben index in der ArrayList 0,1,2,3
- dann wird das Objekt mit index 3 entfernt
- auf dem Canvas werden dann aber nur die Objekte mit Index 0 und 2 gezeichnet, 1 wird ausgelassen
- vergrößert man das Beispiel, ist es das selbe Spiel, es wird jedes zweite Element nicht dargestellt.

Hier einmal der zugehörige Code der Methode zum entfernen des Rechtecks mit der for-Schleife zum erneuten zeichnen:
Java:
             //anzahlElemente zählt die vorhandenen Rechtecke
            //Subtrahieren von 1 von anzahlElemente, wenn ein Stein abgenommen wird
            anzahlElemente--;
        
            //aktualisieren des Labels welches das aktuelle Stapelgewicht anzeigt
            aktuellesGewichtLabel.setText(spielStapel.getStapelGewicht());
        
            //Aufrufen des Graphicscontext zum Zeichnen der Steine auf der GUI
            GraphicsContext g = stapelCanvas.getGraphicsContext2D();
        
            //Loeschen der angezeigten Steine bevor die noch vorhandenen Steine wieder angezeigt werden
            g.clearRect(0, 0, 355, 359);
        
            //Loeschen des zuletzt hinzugefuegten Rechtecks aus der ArrayList
            speicherRechtecke.remove(anzahlElemente);
        
          //Schleife zum zeichnen der verbliebenen Rechtecke
            for(int i = 0; i < speicherRechtecke.size(); i++) {
                RechteckDaten stein = speicherRechtecke.get(i);
                zeichneRechtecke(stein.getX(), stein.getY(), stein.getBreite(), stein.getForm());
                i++;
            }
        
     ;

Hier noch die Methode, die aufgerufen wird um die Rechtecke zu zeichnen:

Java:
    private void zeichneRechtecke(double x, int y, double breite, String typ) {
        //festlegen der Hoehe der Spielsteine in der GUI
        int hoehe = 15;
    
        //Aufrufen des Graphicscontext zum Zeichnen der Steine auf der GUI
        GraphicsContext g = stapelCanvas.getGraphicsContext2D();
        
        //Erstellen des Rechtecks auf der GUI
        g.strokeRect(x, y, breite, hoehe);
    
        //Hinzufuegen eines Textes zum Spielstein
        g.strokeText(typ, x + breite + 5, y + 10 );
    
    }

Vielleicht hat ja einer von euch eine Idee oder sieht meinen Denkfehler... 😅
Vielen Dank schon mal für eure Hilfe!
 
Java:
for(int i = 0; i < speicherRechtecke.size(); i++) {
    RechteckDaten stein = speicherRechtecke.get(i);
    zeichneRechtecke(stein.getX(), stein.getY(), stein.getBreite(), stein.getForm());
    i++;
}
Lies dir das nochmal Zeile fuer Zeile durch. Wenn das nicht hilft, lass dir jedes Rechteck, und den zugehoerigen Index, ausgeben auf der Konsole.

Auszerdem kannst du an der Stelle eine for-each verwenden.
 
Lies dir das nochmal Zeile fuer Zeile durch. Wenn das nicht hilft, lass dir jedes Rechteck, und den zugehoerigen Index, ausgeben auf der Konsole.

Auszerdem kannst du an der Stelle eine for-each verwenden.
Habe mir jetzt mal den Index beim speichern und beim wieder zeichnen ausgeben lassen. Das Problem scheint schon beim Speichern zu sein, hier wird aus irgendeinem Grund nur jedes zweite Rechteck gespeichert, als Index 0,2,4 usw... Index 1,3,5 wird nicht belegt bzw. übersprungen...

Hier mal der Code in dem die Objekte ins Array geschrieben werden:
Java:
        if((spielStapel.berechneStapelgewicht() + steinZumAuflegen.getGewicht() <= spielStapel.getMaxGewicht())) {
           
            String form = steinZumAuflegen.getForm();
           
            double startX;
               
            if(anzahlElemente == 0) {
               
                startX = 30;
               
                if(form.equals("Zylinder (rund)")) {
                           
                    spielStapel.steinAuflegen(steinZumAuflegen);

                    //Zeichnen des Rechtecks auf dem Canvas
                    zeichneRechtecke(startX, startY, steinZumAuflegen.getLangeSeite() * 2 * 7, "rund");
                   
                    startY -= 15;

                    //Erstellen des Objektes mit den Daten des Rechtecks                   
                    RechteckDaten daten = new RechteckDaten(startX, startY, steinZumAuflegen.getLangeSeite() * 2 * 7, "rund");
                   
                    //Speichern des Objektes mit den Daten in der ArrayList
                    speicherRechtecke.add(anzahlElemente, daten);
                   
                    //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                    anzahlElemente++;
                   
                } else if (form.equals("Quader (rechteckig)")) {

                   
                    spielStapel.steinAuflegen(steinZumAuflegen);
                    zeichneRechtecke(startX, startY, steinZumAuflegen.getLangeSeite() * 7, "rechteckig");
                   
                    startY -= 15;
                                       
                    RechteckDaten daten = new RechteckDaten(startX, startY, steinZumAuflegen.getLangeSeite() * 7, "rechteckig");
                   
                    speicherRechtecke.add(anzahlElemente, daten);
                   
                    //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                    anzahlElemente++;
                   
                } else {

                   
                    spielStapel.steinAuflegen(steinZumAuflegen);
                    zeichneRechtecke(startX, startY, steinZumAuflegen.getLangeSeite() * 7, "quadratisch");
                   
                    startY -= 15;
                                       
                    RechteckDaten daten = new RechteckDaten(startX, startY, steinZumAuflegen.getLangeSeite() * 7, "quadratisch");
                   
                    speicherRechtecke.add(anzahlElemente, daten);
                   
                    //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                    anzahlElemente++;
                   
                }
            } else {   
               
                if(spielStapel.getFirstType().equals("Zylinder (rund)")) {
                    if(form == "Zylinder (rund)") {
                       
                        double startXneu = 30 + ((spielStapel.getFirstBreite().getLangeSeite() * 7)) - ((steinZumAuflegen.getLangeSeite() * 7));
                               
                        spielStapel.steinAuflegen(steinZumAuflegen);
                        zeichneRechtecke(startXneu, startY, steinZumAuflegen.getLangeSeite() * 2 * 7, "rund");
                       
                        startY -= 15;                       
                               
                        RechteckDaten daten = new RechteckDaten(startXneu, startY, steinZumAuflegen.getLangeSeite() * 2 * 7, "rund");
                       
                        speicherRechtecke.add(anzahlElemente, daten);
                       
                        //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                        anzahlElemente++;
                       
                    } else if (form.equals("Quader (rechteckig)")) {
                        double startXneu = 30 + ((spielStapel.getFirstBreite().getLangeSeite() * 7)) - ((steinZumAuflegen.getLangeSeite() * 7) / 2);
       
                       
                        spielStapel.steinAuflegen(steinZumAuflegen);
                        zeichneRechtecke(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "rechteckig");
                       
                        startY -= 15;
                                               
                        RechteckDaten daten = new RechteckDaten(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "rechteckig");
                       
                        speicherRechtecke.add(anzahlElemente, daten);
                       
                        //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                        anzahlElemente++;
                       
                    } else {
                        double startXneu = 30 + ((spielStapel.getFirstBreite().getLangeSeite() * 7)) - ((steinZumAuflegen.getLangeSeite() * 7) / 2);
       
                       
                        spielStapel.steinAuflegen(steinZumAuflegen);
                        zeichneRechtecke(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "quadratisch");
                       
                        startY -= 15;
                                               
                        RechteckDaten daten = new RechteckDaten(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "rund");
                       
                        speicherRechtecke.add(anzahlElemente, daten);
                       
                        //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                        anzahlElemente++;
                    }
                   
                } else {
                    if(form.equals("Zylinder (rund)")) {
                        double startXneu = 30 + ((spielStapel.getFirstBreite().getLangeSeite() * 7)  / 2 ) - ((steinZumAuflegen.getLangeSeite() * 7));
                               
                        spielStapel.steinAuflegen(steinZumAuflegen);
                        zeichneRechtecke(startXneu, startY, steinZumAuflegen.getLangeSeite() * 2 * 7, "rund");
                       
                        startY -= 15;                       
                                   
                        RechteckDaten daten = new RechteckDaten(startXneu, startY, steinZumAuflegen.getLangeSeite() * 2 * 7, "rund");
                       
                        speicherRechtecke.add(anzahlElemente, daten);
                       
                        //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                        anzahlElemente++;
                       
                    } else if (form.equals("Quader (rechteckig)")) {
                        double startXneu = 30 + ((spielStapel.getFirstBreite().getLangeSeite() * 7) / 2 ) - ((steinZumAuflegen.getLangeSeite() * 7) / 2);
       
                       
                        spielStapel.steinAuflegen(steinZumAuflegen);
                        zeichneRechtecke(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "rechteckig");
                       
                        startY -= 15;
                                               
                        RechteckDaten daten = new RechteckDaten(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "rechteckig");
                       
                        speicherRechtecke.add(anzahlElemente, daten);
                       
                        //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                        anzahlElemente++;
                       
                    } else {
                        double startXneu = 30 + ((spielStapel.getFirstBreite().getLangeSeite() * 7) / 2 ) - ((steinZumAuflegen.getLangeSeite() * 7) / 2);
       
                       
                        spielStapel.steinAuflegen(steinZumAuflegen);
                        zeichneRechtecke(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "quadratisch");
                       
                        startY -= 15;
                                               
                        RechteckDaten daten = new RechteckDaten(startXneu, startY, steinZumAuflegen.getLangeSeite() * 7, "quadratisch");
                       
                        speicherRechtecke.add(anzahlElemente, daten);
                       
                        //anzahlElemente wird um eins erhoeht, wenn Stein hinzugefuegt wurde
                        anzahlElemente++;
                       
                    }
                }           
           
                //aktualisieren des Labels, welches das aktuelle Stapelgewicht abbildet
                aktuellesGewichtLabel.setText(spielStapel.getStapelGewicht());
           
            }
           
          }
           
        }
Das ist der komplette Code, es gibt viele verschiedene Bedingungen, die nur Kleinigkeiten unterscheiden, aber in denen ist dann der Ablauf im Endeffekt immer der Gleiche.
Hierbei ist die Zählvariable anzahlElemente logischerweise am Anfang null und wird erhöht sobald ein Objekt hinzugefügt wird. Dementsprechend wird das Objekt dann auch an der Stelle in die ArrayList geschrieben. Oder steht die Erhöhung der Zählvariable hier an der falschen Stelle?
 
Zuletzt bearbeitet:

Zurück
Oben