1 files changed, 205 insertions, 0 deletions

diff --git a/ws2015/eip/blaetter/07/H7-1C/de/lmu/tcs/Spielfeld.java b/ws2015/eip/blaetter/07/H7-1C/de/lmu/tcs/Spielfeld.java
new file mode 100644
index 0000000..1044c1e
--- /dev/null
+++ b/ws2015/eip/blaetter/07/H7-1C/de/lmu/tcs/Spielfeld.java
@@ -0,0 +1,205 @@
+package de.lmu.tcs;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+/**
+ * Model
+ *
+ * Created by jost on 24.11.15.
+ */
+public class Spielfeld {
+
+    private final Zelle[][] feld;
+    private final int max_x; //Breite
+    private final int max_y; //Höhe
+
+    public Spielfeld(int breite, int höhe) {
+        this.max_x = breite;
+        this.max_y = höhe;
+        feld = new Zelle[this.max_x][this.max_y];
+        for (int y = 0; y < max_y; y++) {
+            for (int x=0;x<max_x - (y % 2);x++) {
+                final Position p = new Position(x, y);
+                feld[x][y] = new Zelle(p, Zelle.TOT);
+            }
+        }
+    }
+
+    private boolean isValid(int x, int y)
+    {
+        return x >= 0 && x < max_x && y >= 0 && y < max_y;
+    }
+
+    /**
+     * Liefert Zelle des Spielfelds an einer Position.
+     * @param p Position, der Zelle ausgelesen werden soll
+     * @return Zelle des Spielfelds an dieser Position, falls vorhanden; sonst null.
+     */
+    public Zelle getZelle(Position p) {
+        if (isValid(p.getX(), p.getY())) {
+            return feld[p.getX()][p.getY()];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Setzt eine gegebene Zelle ins Spielfeld ein.
+     * Überschreibt vorherige Zelle.
+     *
+     * @param zelle Einzusetzende Zelle
+     * @return Ob die Position der Zelle im Spielfeld enthalten ist (false bedeutuet ungültig).
+     */
+    public boolean setZelle(Zelle zelle) {
+        final Position p = zelle.getPosition();
+        if (isValid(p.getX(), p.getY())) {
+            feld[p.getX()][p.getY()] = zelle;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Liefert das gesamte Spielfeld direkt aus;
+     * nicht so schöne, da interne Repräsentierung offenbart wird
+     * und das Array von aussen verändert werden kann! Autsch!
+     *
+     * @return Alle Zellen des Felds im 2D array
+     */
+    public Zelle[][] getFeld() {
+        return feld;
+    }
+
+    /**
+     * BESSERE ALTERNATIVE zu getter-Methode getFeld():
+     * Liefert alle Zellen des Spielfeldes aus. Vorteile:
+     * 1) Interne Repräsentation bleibt versteckt.
+     * 2) Da die Zellen immutable sind, kann hier das
+     * Spielfeld auch nicht woanders manipuliert werden.
+     *
+     * @return Alle Zellen des Spielfeldes als ArrayList
+     */
+    public ArrayList<Zelle> getZellen() {
+        ArrayList<Zelle> result = new ArrayList<>(max_x*max_y);
+        for (int x=0;x<max_x;x++) {
+            for (int y = 0; y < max_y; y++) {
+                result.add(feld[x][y]);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Genau wie getZellen, nur mit echtem Array anstatt ArrayList.
+     * Vorteile bleiben erhalten!
+     *
+     * @return Alle Zellen des Spielfeldes als Array
+     */
+    public Zelle[] getZellenAry() {
+        Zelle[] result = new Zelle[max_x*max_y];
+        int i = 0;
+        for (int x=0;x<max_x;x++) {
+            for (int y = 0; y < max_y; y++) {
+                result[i] = feld[x][y];
+                i++;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Berechnet alle Nachbarn einer Zelle.
+     *
+     * @param zelle deren Nachbarn berechnet werden sollen
+     * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
+     */
+    public ArrayList<Zelle> getNachbarn(Zelle zelle) {
+        ArrayList<Zelle> result = new ArrayList<>();
+        if (zelle == null)
+            return result;
+        Position pos = zelle.getPosition();
+        Position[] offsets = { new Position(0, -1), new Position(1, -1)
+                               , new Position(-1, 0), new Position(1, 0)
+                               , new Position(0, 1), new Position (1, 1)
+        };
+        for (Position offset : offsets) {
+            Zelle nachbar = this.getZelle(pos.add(offset));
+            if (nachbar != null) {
+                result.add(nachbar);
+            }
+        }
+        return result;
+    }
+
+   //  /**
+   //   * Berechnet alle Nachbarn einer Zelle.
+   //   * Variante von getNachbar mit Array anstatt ArrayList
+   //   *
+   //   * @param zelle deren Nachbarn berechnet werden sollen
+   //   * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
+   //   */
+   // public Zelle[] getNachbarnAry(Zelle zelle) {
+   //      Position pos = zelle.getPosition();
+   //      int minx = Math.max(pos.getX() - 1, 0);
+   //      int maxx = Math.min(pos.getX() + 1, this.max_x);
+   //      int miny = Math.max(pos.getY() - 1, 0);
+   //      int maxy = Math.min(pos.getY() + 1, this.max_y);
+   //      Zelle[] result = new Zelle[maxx - minx * maxy - miny];
+   //      int i = 0;
+   //      for (int x = minx; x <= maxx; x++) {
+   //          for (int y = miny; y <= maxy; y++) {
+   //              if (x!=0 || y!=0) {
+   //                  result[i] = feld[x][y];
+   //                  i++;
+   //              }
+   //          }
+   //      }
+   //      return result;
+   //  }
+
+    /**
+     * Berechnet alle Nachbarn einer Zelle auf Wrap-Around Spielfeld..
+     *
+     * @param zelle deren Nachbarn berechnet werden sollen
+     * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
+     */
+    public ArrayList<Zelle> getNachbarnWrapped(Zelle zelle) {
+        ArrayList<Zelle> result = new ArrayList<Zelle>(8);
+        Position pos = zelle.getPosition();
+        for (int x = -1; x <= 1; x++) {
+            for (int y = -1; y <= 1; y++) {
+                if (x!=0 || y!=0) {
+                    Zelle z =  getZelle(new Position((pos.getX() + x + max_x )% max_x, (pos.getY() + y + max_y) % max_y));
+                    result.add(z);
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Berechnet alle Nachbarn einer Zelle auf Warap-Around Spielfeld.
+     * Variante von getNachbarWrapped mit Array anstatt ArrayList
+     *
+     * @param zelle deren Nachbarn berechnet werden sollen
+     * @return alle Nachbarn von {@code zelle}, Anzahl Nachbarn variabel
+     */
+    public Zelle[] getNachbarnAryWrapped(Zelle zelle) {
+        Zelle[] result = new Zelle[8];
+        Position pos = zelle.getPosition();
+        int i = 0;
+        for (int x = -1; x <= 1; x++) {
+            for (int y = -1; y <= 1; y++) {
+                if (x!=0 || y!=0) {
+                    Zelle z =  getZelle(new Position((pos.getX() + x + max_x )% max_x, (pos.getY() + y + max_y) % max_y));
+                    result[i] = z;
+                    i++;
+                }
+            }
+        }
+        return result;
+    }
+}