From 0ad31dcca37df9891ed5d5b70f12a966fc821c6d Mon Sep 17 00:00:00 2001
From: Gregor Kleen <gkleen@yggdrasil.li>
Date: Thu, 3 Dec 2015 04:34:54 +0000
Subject: EiP - 07

---
 ws2015/eip/blaetter/07/de/lmu/tcs/Spielfeld.java | 198 +++++++++++++++++++++++
 1 file changed, 198 insertions(+)
 create mode 100644 ws2015/eip/blaetter/07/de/lmu/tcs/Spielfeld.java

(limited to 'ws2015/eip/blaetter/07/de/lmu/tcs/Spielfeld.java')

diff --git a/ws2015/eip/blaetter/07/de/lmu/tcs/Spielfeld.java b/ws2015/eip/blaetter/07/de/lmu/tcs/Spielfeld.java
new file mode 100644
index 0000000..7b9ec60
--- /dev/null
+++ b/ws2015/eip/blaetter/07/de/lmu/tcs/Spielfeld.java
@@ -0,0 +1,198 @@
+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 x=0;x<max_x;x++) {
+            for (int y = 0; y < max_y; y++) {
+                final Position p = new Position(x, y);
+                feld[x][y] = new Zelle(p, Zelle.TOT);
+            }
+        }
+    }
+
+    /**
+     * 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 (p.getX() >= 0 && p.getX() < max_x && p.getY() >= 0 && p.getY() < max_y) {
+            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 (p.getX() >= 0 && p.getX() < max_x && p.getY() >= 0 && p.getY() < max_y) {
+            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<>();
+        Position pos = zelle.getPosition();
+        for (int x=-1; x<=1; x++) {
+            for (int y = -1; y <= 1; y++) {
+                if (x!=0 || y!=0) {
+                    Zelle nachbar = this.getZelle(new Position(pos.getX() + x, pos.getY() + y));
+                    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;
+    }
+}
-- 
cgit v1.2.3