Real rename

Projektgruppe_175/src/base/Edge.java

@@ -0,0 +1,54 @@
+package base;
+
+/**
+ * Diese Klasse representiert eine generische Kante zwischen zwei Knoten
+ * @param <T> die zugrunde liegende Datenstruktur
+ */
+public class Edge<T> {
+
+    private Node<T> nodeA, nodeB;
+
+    /**
+     * Erstellt eine neue Kante zwischen zwei gegebenen Knoten
+     * @param nodeA der erste Knoten
+     * @param nodeB der zweite Knoten
+     */
+    Edge(Node<T> nodeA, Node<T> nodeB) {
+        this.nodeA = nodeA;
+        this.nodeB = nodeB;
+    }
+
+    /**
+     * Gibt an, ob die Kante mit dem gegebenen Knoten verbunden ist
+     * @param node Der Knoten der überprüft wird
+     * @return true, wenn die Kante mit dem Knoten verbunden ist
+     */
+    boolean contains(Node<T> node) {
+        return nodeA == node || nodeB == node;
+    }
+
+    /**
+     * Gibt den ersten Knoten zurück
+     * @return der erste Knoten
+     */
+    public Node<T> getNodeA() {
+        return nodeA;
+    }
+
+    /**
+     * Gibt den zweiten Knoten zurück
+     * @return der zweite Knoten
+     */
+    public Node<T> getNodeB() {
+        return nodeB;
+    }
+
+    /**
+     * Gibt den jeweils anderen Knoten zurück, abhängig von dem gegebenen
+     * @param source der eine Knoten
+     * @return der andere Knoten
+     */
+    public Node<T> getOtherNode(Node<T> source) {
+        return (nodeA == source ? nodeB : nodeA);
+    }
+}

Projektgruppe_175/src/base/Graph.java

@@ -0,0 +1,127 @@
+package base;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collector;
+
+import game.map.Castle;
+
+/**
+ * Diese Klasse representiert einen generischen Graphen mit einer Liste aus Knoten und Kanten.
+ *
+ * @param <T> Die zugrundeliegende Datenstruktur, beispielsweise {@link game.map.Castle}
+ */
+public class Graph<T> {
+
+    private List<Edge<T>> edges;
+    private List<Node<T>> nodes;
+
+    /**
+     * Konstruktor für einen neuen, leeren Graphen
+     */
+    public Graph() {
+        this.nodes = new ArrayList<>();
+        this.edges = new LinkedList<>();
+    }
+
+    /**
+     * Einen neuen Knoten zum Graphen hinzufügen
+     * @param value Der Wert des Knotens
+     * @return Der erstellte Knoten
+     */
+    public Node<T> addNode(T value) {
+        Node<T> node = new Node<>(value);
+        this.nodes.add(node);
+        return node;
+    }
+
+    /**
+     * Eine neue Kante zwischen zwei Knoten hinzufügen. Sollte die Kante schon existieren, wird die vorhandene Kante zurückgegeben.
+     * @param nodeA Der erste Knoten
+     * @param nodeB Der zweite Knoten
+     * @return Die erstellte oder bereits vorhandene Kante zwischen beiden gegebenen Knoten
+     */
+    public Edge<T> addEdge(Node<T> nodeA, Node<T> nodeB) {
+        Edge<T> edge = getEdge(nodeA, nodeB);
+        if(edge != null) {
+            return edge;
+        }
+
+        edge = new Edge<>(nodeA, nodeB);
+        this.edges.add(edge);
+        return edge;
+    }
+
+    /**
+     * Gibt die Liste aller Knoten zurück
+     * @return die Liste aller Knoten
+     */
+    public List<Node<T>> getNodes() {
+        return this.nodes;
+    }
+
+    /**
+     * Gibt die Liste aller Kanten zurück
+     * @return die Liste aller Kanten
+     */
+    public List<Edge<T>> getEdges() {
+        return this.edges;
+    }
+
+    /**
+     * Diese Methode gibt alle Werte der Knoten in einer Liste mittels Streams zurück.
+     * @see java.util.stream.Stream#map(Function)
+     * @see java.util.stream.Stream#collect(Collector)
+     * @return Eine Liste aller Knotenwerte
+     */
+    public List<T> getAllValues() {
+        // TODO: Graph<T>#getAllValues()
+        return new ArrayList<>();
+    }
+
+    /**
+     * Diese Methode gibt alle Kanten eines Knotens als Liste mittels Streams zurück.
+     * @param node Der Knoten für die dazugehörigen Kanten
+     * @see java.util.stream.Stream#filter(Predicate)
+     * @see java.util.stream.Stream#collect(Collector)
+     * @return Die Liste aller zum Knoten zugehörigen Kanten
+     */
+    public List<Edge<T>> getEdges(Node<T> node) {
+        // TODO: Graph<T>#getEdges(Node<T>)
+        return new ArrayList<>();
+    }
+
+    /**
+     * Diese Methode sucht eine Kante zwischen beiden angegebenen Knoten und gibt diese zurück
+     * oder null, falls diese Kante nicht existiert
+     * @param nodeA Der erste Knoten
+     * @param nodeB Der zweite Knoten
+     * @return Die Kante zwischen beiden Knoten oder null
+     */
+    public Edge<T> getEdge(Node<T> nodeA, Node<T> nodeB) {
+        // TODO: Graph<T>#getEdge(Node<T>, Node<T>)
+        return null;
+    }
+
+    /**
+     * Gibt den ersten Knoten mit dem angegebenen Wert zurück oder null, falls dieser nicht gefunden wurde
+     * @param value Der zu suchende Wert
+     * @return Ein Knoten mit dem angegebenen Wert oder null
+     */
+    public Node<T> getNode(T value) {
+        // TODO: Graph<T>#getNode(T)
+        return null;
+    }
+    
+    /**
+     * Überprüft, ob alle Knoten in dem Graphen erreichbar sind.
+     * @return true, wenn alle Knoten erreichbar sind
+     */
+    public boolean allNodesConnected() {
+    	// TODO: Graph<T>#allNodesConnected()
+        return false;
+    }
+}

Projektgruppe_175/src/base/GraphAlgorithm.java

@@ -0,0 +1,118 @@
+package base;
+
+import java.util.*;
+
+/**
+ * Abstrakte generische Klasse um Wege zwischen Knoten in einem Graph zu finden.
+ * Eine implementierende Klasse ist beispielsweise {@link game.map.PathFinding}
+ * @param <T> Die Datenstruktur des Graphen
+ */
+public abstract class GraphAlgorithm<T> {
+
+    /**
+     * Innere Klasse um {@link Node} zu erweitern, aber nicht zu verändern
+     * Sie weist jedem Knoten einen Wert und einen Vorgängerknoten zu.
+     * @param <T>
+     */
+    private static class AlgorithmNode<T> {
+
+        private Node<T> node;
+        private double value;
+        private AlgorithmNode<T> previous;
+
+        AlgorithmNode(Node<T> parentNode, AlgorithmNode<T> previousNode, double value) {
+            this.node = parentNode;
+            this.previous = previousNode;
+            this.value = value;
+        }
+    }
+
+    private Graph<T> graph;
+
+    // Diese Liste enthält alle Knoten, die noch nicht abgearbeitet wurden
+    private List<Node<T>> availableNodes;
+
+    // Diese Map enthält alle Zuordnungen
+    private Map<Node<T>, AlgorithmNode<T>> algorithmNodes;
+
+    /**
+     * Erzeugt ein neues GraphAlgorithm-Objekt mit dem dazugehörigen Graphen und dem Startknoten.
+     * @param graph der zu betrachtende Graph
+     * @param sourceNode der Startknoten
+     */
+    public GraphAlgorithm(Graph<T> graph, Node<T> sourceNode) {
+        this.graph = graph;
+        this.availableNodes = new LinkedList<>(graph.getNodes());
+        this.algorithmNodes = new HashMap<>();
+
+        for(Node<T> node : graph.getNodes())
+            this.algorithmNodes.put(node, new AlgorithmNode<>(sourceNode, null, -1));
+
+        this.algorithmNodes.get(sourceNode).value = 0;
+    }
+
+    /**
+     * Diese Methode gibt einen Knoten mit dem kleinsten Wert, der noch nicht abgearbeitet wurde, zurück und entfernt ihn aus der Liste {@link #availableNodes}.
+     * Sollte kein Knoten gefunden werden, wird null zurückgegeben.
+     * Verbindliche Anforderung: Verwenden Sie beim Durchlaufen der Liste Iteratoren
+     * @return Der nächste abzuarbeitende Knoten oder null
+     */
+    private AlgorithmNode<T> getSmallestNode() {
+        // TODO: GraphAlgorithm<T>#getSmallestNode()
+        return null;
+    }
+
+    /**
+     * Diese Methode startet den Algorithmus. Dieser funktioniert wie folgt:
+     * 1. Suche den Knoten mit dem geringsten Wert (siehe {@link #getSmallestNode()})
+     * 2. Für jede angrenzende Kante:
+     * 2a. Überprüfe ob die Kante passierbar ist ({@link #isPassable(Edge)})
+     * 2b. Berechne den Wert des Knotens, in dem du den aktuellen Wert des Knotens und den der Kante addierst
+     * 2c. Ist der alte Wert nicht gesetzt (-1) oder ist der neue Wert kleiner, setze den neuen Wert und den Vorgängerknoten
+     * 3. Wiederhole solange, bis alle Knoten abgearbeitet wurden
+
+     * Nützliche Methoden:
+     * @see #getSmallestNode()
+     * @see #isPassable(Edge)
+     * @see Graph#getEdges(Node)
+     * @see Edge#getOtherNode(Node)
+     */
+    public void run() {
+        // TODO: GraphAlgorithm<T>#run()
+    }
+
+    /**
+     * Diese Methode gibt eine Liste von Kanten zurück, die einen Pfad zu dem angegebenen Zielknoten representiert.
+     * Dabei werden zuerst beginnend mit dem Zielknoten alle Kanten mithilfe des Vorgängerattributs {@link AlgorithmNode#previous} zu der Liste hinzugefügt.
+     * Zum Schluss muss die Liste nur noch umgedreht werden. Sollte kein Pfad existieren, geben Sie null zurück.
+     * @param destination Der Zielknoten des Pfads
+     * @return eine Liste von Kanten oder null
+     */
+    public List<Edge<T>> getPath(Node<T> destination) {
+        // TODO: GraphAlgorithm<T>#getPath(Node<T>)
+        return null;
+    }
+
+    /**
+     * Gibt den betrachteten Graphen zurück
+     * @return der zu betrachtende Graph
+     */
+    protected Graph<T> getGraph() {
+        return this.graph;
+    }
+
+    /**
+     * Gibt den Wert einer Kante zurück.
+     * Diese Methode ist abstrakt und wird in den implementierenden Klassen definiert um eigene Kriterien für Werte zu ermöglichen.
+     * @param edge Eine Kante
+     * @return Ein Wert, der der Kante zugewiesen wird
+     */
+    protected abstract double getValue(Edge<T> edge);
+
+    /**
+     * Gibt an, ob eine Kante passierbar ist.
+     * @param edge Eine Kante
+     * @return true, wenn die Kante passierbar ist.
+     */
+    protected abstract boolean isPassable(Edge<T> edge);
+}

Projektgruppe_175/src/base/Node.java

@@ -0,0 +1,26 @@
+package base;
+
+/**
+ * Diese Klasse representiert einen generischen Knoten
+ * @param <T>
+ */
+public class Node<T> {
+
+    private T value;
+
+    /**
+     * Erzeugt einen neuen Knoten mit dem gegebenen Wert
+     * @param value der Wert des Knotens
+     */
+    Node(T value) {
+        this.value = value;
+    }
+
+    /**
+     * Gibt den Wert des Knotens zurück
+     * @return der Wert des Knotens
+     */
+    public T getValue() {
+        return value;
+    }
+}

Projektgruppe_175/src/base/PerlinNoise.java

@@ -0,0 +1,153 @@
+package base;
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Random;
+
+/**
+ * @author Philipp Imperatori, Nils Nedderhut, Louis Neumann
+ * modified by Roman Hergenreder
+ * <p>
+ * Version 1.0
+ */
+public class PerlinNoise {
+
+    private int width ;
+    private int height;
+    private int scale;
+
+    private int gwidth; // scaled width
+    private int gheight; // scaled height
+
+    private Random random;
+    private ArrayList<Vector<Double>> Vectors; //gradients
+
+    public PerlinNoise(int width, int height, int scale) {
+
+        this.width = width * scale;
+        this.height = height * scale;
+        this.scale = scale;
+        this.gwidth = width;
+        this.gheight = height;
+
+        this.random = new Random();
+        this.Vectors = new ArrayList<>();
+        createVectors((1 + gwidth) * (1 + gheight));
+    }
+
+    public Dimension getRealSize() {
+        return new Dimension(this.width, this.height);
+    }
+
+    public Dimension getScaledSize() {
+        return new Dimension(this.gwidth, this.gheight);
+    }
+
+    /**
+     * create's a list with n elements where each element is a vector in the union circle (gradient)
+     * @param n: number of gradients to be created
+     */
+    private void createVectors(int n) {
+        this.Vectors = new ArrayList<>();
+        for(int i=0;i<n;i++){
+            double randomValue = random.nextDouble();
+            randomValue = randomValue * 2 * Math.PI;
+            double x = Math.cos(randomValue);
+            double y = Math.sin(randomValue);
+            Vector<Double> grad = new Vector<>(x,y);
+            this.Vectors.add(grad);
+        }
+    }
+
+    /**
+     * Uses a Sigmoid function to smooth numbers betwenn 0 to 1
+     * @param t: number to smooth
+     * @return smoothed number
+     */
+    private double fade(double t){
+        return (((6*(t*t*t*t*t))-(15*t*t*t*t))+(10*t*t*t));
+    }
+
+    /** Computes a weighted linear interpolation with point (x,y) and weight w
+     * @param x: value of x-coordinate
+     * @param y: value of y-coordinate
+     * @param w: weight w to interpolate
+     * @return result of linear interpolation
+     */
+    private double linearInterpolation(double x, double y, double w){
+        return ((1.0-w)*x+w*y);
+    }
+
+    /**
+     * Calculates the scalar product between the direction vector and the gradient in the corner
+     * @param vector: direction vector
+     * @param gradient: gradient in the corner
+     * @return scalar product
+     */
+    private double scalarVekGrad(Vector<Double> vector, Vector<Double> gradient){
+        return (vector.getX()*gradient.getX() + vector.getY()*gradient.getY());
+    }
+
+    /**
+     * Converts the value from its old interval [oldMin,oldMax] to a new interval [newMin,newMax]
+     * @param value : value to be converted
+     * @return converted value
+     */
+    private double mapToInterval(double value) {
+        return (value + 1.0)/2.0;
+    }
+
+
+    /**
+     * Creates the noise value for the given point (x,y)
+     * @param x: x-coordinate of point
+     * @param y: y-coordinate of point
+     * @return noise of point
+     */
+    public double getNoise (double x, double y) {
+        if (x >= width || y >= height) {
+            System.out.println("ERROR: x or/and y is not in picture");
+            return 0;
+        }
+
+        double scaledX = x / this.scale;
+        double scaledY = y / this.scale;
+
+        //Left upper edge
+        int xlo = (int) scaledX;
+        int ylo = (int) scaledY;
+
+        //right upper egde
+        int xro = ((int) scaledX)+1;
+        int yro = ((int) scaledY);
+
+        //left lower edge
+        int xlu = (int) scaledX;
+        int ylu = ((int) scaledY)+1;
+
+        //right lower edge
+        int xru = ((int) scaledX)+1;
+        int yru = ((int) scaledY)+1;
+
+        // int cell_nr = xlo+(ylo*this.gwidth);
+
+        Vector<Double> gradLO = this.Vectors.get(xlo+(ylo*(this.gwidth+1)));
+        Vector<Double> gradRO = this.Vectors.get(xro+(yro*(this.gwidth+1)));
+        Vector<Double> gradLU = this.Vectors.get(xlu+((ylu)*(this.gwidth+1)));
+        Vector<Double> gradRU = this.Vectors.get(xru+((yru)*(this.gwidth+1)));
+
+        Vector<Double> rvLO = new Vector<>(scaledX - xlo,scaledY - ylo);
+        Vector<Double> rvRO = new Vector<>(scaledX - xro,scaledY - yro);
+        Vector<Double> rvLU = new Vector<>(scaledX - xlu,scaledY - ylu);
+        Vector<Double> rvRU = new Vector<>(scaledX - xru,scaledY - yru);
+
+        //upper edges
+        double linIntOben = this.linearInterpolation(this.scalarVekGrad(rvLO,gradLO),this.scalarVekGrad(rvRO,gradRO),this.fade(rvLO.getX()));
+
+        //lower edges
+        double linIntUnten = this.linearInterpolation(this.scalarVekGrad(rvLU,gradLU),this.scalarVekGrad(rvRU,gradRU),this.fade(rvLO.getX()));
+
+        //final interpolation
+        return this.mapToInterval(this.linearInterpolation(linIntOben,linIntUnten,this.fade(rvLO.getY())));
+    }
+}

Projektgruppe_175/src/base/Vector.java

@@ -0,0 +1,33 @@
+package base;
+
+/**
+ * @author Philipp Imperatori, Nils Nedderhut, Louis Neumann
+ * <p>
+ * Version 1.0
+ */
+public class Vector<T> {
+
+    private T x;
+    private T y;
+
+    public Vector(T x, T y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public T getX() {
+        return this.x;
+    }
+
+    public T getY() {
+        return this.y;
+    }
+
+    public void setX(T x) {
+        this.x = x;
+    }
+
+    public void setY(T y) {
+        this.y = y;
+    }
+}