[Underkane]

Aufgabenstellung: Rechteckschachtelung

Eine Fläche soll mit Rechtecken gefüllt werden, dass ein Rechteck zwei Rechtecke enthält. Jedes dieser Rechtecke enthält wieder zwei Rechtecke usw. Damit die Rechtecke unterschiedlich geschachtelt werden und unterschiedliche Farben besitzen, sollen die Teilungsstelle und die Farbe jeweils per Zufall ermittelt werden.


So wie ich den Text verstanden habe, soll ein Rechteck erstellt werden, das zwei Rechtecke enthält, die wieder je zwei Rechtecke enthalten, usw.
Ob die Teilung horizontal oder vertikal sowie in welcher Farbe erfolgt soll zufällig sein.


Mir fehlt jedoch der richtige Ansatz um das zu lösen.

Was ich bis jetzt habe:

import javax.swing.JFrame;

public class Main extends JFrame {
    final static int WINDOW_WIDTH = 800, WINDOW_HEIGHT = 600;
    
    public Main() {
        setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
        setResizable(false);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        add(new Controller());
        setVisible(true);
    }
    
    public static void main(String[] args) {
        new Main();
    }
}

import javax.swing.JPanel;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.Timer;
import java.awt.Graphics;
import java.awt.Color;

public class Controller extends JPanel implements ActionListener {
    public Controller() {
        Timer timer = new Timer(1000, this);
        timer.start();
    }
    
    public void paintComponent(Graphics g) {
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, Main.WINDOW_WIDTH, Main.WINDOW_HEIGHT);
    }
    
    public void actionPerformed(ActionEvent e) {
        //teilen
    }
}

import java.awt.Graphics;
import java.awt.Color;

public class Rectangle {
    private int x, y;
    private int width, height;
    
    public Rectangle(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }
    
    public void paint(Graphics g) {
        //farbe g.setColor(Color.WHITE);
        g.fillRect(x, y, width, height);
    }
    
    public int getX() {
        return x;
    }
    
    public int getY() {
        return y;
    }
    
    public int getWidth() {
        return width;
    }
    
    public int getHeight() {
        return height;
    }
}

[d03jo4n]

Das ganze könntest du rekursiv lösen.
Dafür solltest du beim repaint auf jeden Fall double buffering verwenden.

In der rekursiven Methode solltest du

• entscheiden, wie geteilt wird (horizontal/vertikal) und
• die Breite eines Feldes ermitteln (Zufall) und die andere bestimmen

Danach rufst du die Methode dann rekursiv für jedes Teilrechteck auf.
Dafür kannst du die von dir geschriebene Klasse Rectangle verwenden.
Die rekursive Methode könnte also zum Beispiel folgende Signatur haben:

protected void split(Rectangle rect)

Wichtig: Du brauchst eine Verschachtelungstiefe, damit das ganze nicht endlos läuft!