Claim.java

/**
 * Verwaltung einer Fläche (Claim) aus mehreren Parzellen in einem
 * zweidimensionalen Array. Bietet Zugriff auf einzelne Parzellen und eine
 * Stabilitätsprüfung, die auf Differenzen der aktuellen Abbautiefen
 * benachbarter Parzellen basiert.
 */
public class Claim {

    private Parzelle[][] parzellen;
    private int rows;
    private int cols;

    /**
     * Erzeugt einen Claim aus dem übergebenen 2D-Array von Parzellen. Falls
     * `pGrid` null ist, wird ein leeres Array verwendet.
     *
     * @param pGrid 2D-Array mit Parzellen (Zeilen x Spalten)
     */
    public Claim(Parzelle[][] pGrid) {
        if (pGrid == null) {
            this.parzellen = new Parzelle[0][0];
            this.rows = 0;
            this.cols = 0;
        } else {
            this.parzellen = pGrid;
            this.rows = parzellen.length;
            if (parzellen.length > 0 && parzellen[0] != null) {
                this.cols = parzellen[0].length;
            } else {
                this.cols = 0;
            }

        }
    }

    /**
     * Liefert die Parzelle an der angegebenen Position oder `null`, falls die
     * Koordinaten außerhalb des Bereichs liegen.
     *
     * @param pZeile  Index der Zeile (0-basiert)
     * @param pSpalte Index der Spalte (0-basiert)
     * @return Parzelle oder null
     */
    public Parzelle gibParzelle(int pZeile, int pSpalte) {
        if (pZeile < 0 || pZeile >= rows || pSpalte < 0 || pSpalte >= cols) {
            return null;
        }
        return parzellen[pZeile][pSpalte];
    }

    /**
     * Liefert die Anzahl der Zeilen im Claim.
     *
     * @return Zeilenzahl
     */
    public int gibZeilen() {
        return rows;
    }

    /**
     * Liefert die Anzahl der Spalten im Claim.
     *
     * @return Spaltenzahl
     */
    public int gibSpalten() {
        return cols;
    }

    /**
     * Die Methode prüft für alle Parzellen, ob es zwei benachbarte Parzellen gibt,
     * bei denen der Unterschied
     * der aktuellen Abbautiefen größer ist als `pMax`. In diesem Fall ist der Claim
     * instabil und die Methode
     * liefert false. Andernfalls wird true zurückgegeben. Ist pMax negativ, wird
     * false geliefert.
     *
     * @param pMax maximal erlaubte Tiefendifferenz
     * @return true, falls stabil; false sonst
     */
    public boolean istStabil(double pMax) {
        boolean ergebnis = true;

        // Horizontale Nachbarn prüfen
        for (int i = 0; i < parzellen.length; i++) {
            for (int j = 0; j < parzellen[i].length - 1; j++) {
                if (berechneTiefendifferenz(parzellen[i][j],
                        parzellen[i][j + 1]) > pMax) {
                    ergebnis = false;
                }
            }
        }

        // Vertikale Nachbarn prüfen
        for (int i = 0; i < parzellen.length - 1; i++) {
            for (int j = 0; j < parzellen[i].length; j++) {
                if (berechneTiefendifferenz(parzellen[i][j],
                        parzellen[i + 1][j]) > pMax) {
                    ergebnis = false;
                }
            }
        }

        return ergebnis;
    }

    /**
     * Berechnet die absolute Differenz der aktuellen Abbautiefen zweier
     * Parzellen. Null-Parzellen werden als Tiefe 0.0 betrachtet.
     *
     * @param pParzelle1 erste Parzelle
     * @param pParzelle2 zweite Parzelle
     * @return absolute Differenz der Abbautiefen
     */
    private double berechneTiefendifferenz(Parzelle pParzelle1, Parzelle pParzelle2) {
        double d1 = (pParzelle1 == null) ? 0.0 : pParzelle1.gibtAktuelleAbbautiefe();
        double d2 = (pParzelle2 == null) ? 0.0 : pParzelle2.gibtAktuelleAbbautiefe();
        return Math.abs(d1 - d2);
    }

    /**
     * Baut von der Parzelle an der angegebenen Position bis zu
     * `pTiefe` ab. Liefert die entnommene {@link Erdschicht} oder `null`,
     * falls die Koordinaten ungültig sind, `pTiefe` &lt;= 0 oder keine
     * Schichten mehr vorhanden sind.
     *
     * @param pZeile  Zeilenindex der Parzelle (0-basiert)
     * @param pSpalte Spaltenindex der Parzelle (0-basiert)
     * @param pTiefe  gewünschte Abbautiefe (positiv)
     * @return entnommene {@link Erdschicht} oder null
     */
    public Erdschicht baueParzelleAb(int pZeile, int pSpalte, double pTiefe) {
        if (pZeile < 0 || pZeile >= rows || pSpalte < 0 || pSpalte >= cols) {
            return null;
        }
        Parzelle target = parzellen[pZeile][pSpalte];
        if (target == null) {
            return null;
        }
        return target.baueAb(pTiefe);
    }

}