Merge pull request #30 from TheFehr/Logic

Logic

src/logic/Game.java

@@ -14,6 +14,12 @@
 import logic.graph.Player;
 import logic.graph.Point;
 
+/**
+ * Diese Klasse repräsentert das Spiel an sich un bietet wichtige Funktionen für die Interaktion zwischen Algorithmus/Backend
+ * und Presentation/View/Frontend
+ * @author Lukas Bischof
+ *
+ */
 public class Game {
 	private QuadController quadController;
 	private PathFinder pathFinder;
@@ -48,10 +54,18 @@ protected void setup() {
 		//System.out.println(pathFinder.getGraph().toString(quadController.getDWidth()));
 	}
 
+	/**
+	 * Gibt den idealen Pfad zum Abschuss auf den Player von dem Monster
+	 * @return Den Pfad
+	 */
 	public Path getPathForMonster() {
 		return pathFinder.getBestPathToShootForMonster(monster, player, quadController);
 	}
 
+	/**
+	 * Mit dieser Methode kann man ein export file zum debuggen erstellen
+	 * @param path
+	 */
 	public void export(String path) {
 		BufferedWriter writer = null;
 		try {

src/logic/Index2D.java

@@ -2,6 +2,12 @@
 
 import logic.graph.Point;
 
+/**
+ * Diese Klasse repräsentiert einen zweidimensionalen Index. Gespeichert wird der in Form eines Vektors.
+ * Der X- und Y-Wert kann dabei eine natürliche Zahl zwischen 0 und n annehmen, wobei n die grösse des Feldes in Blocks pro Zeile/Spalte ist
+ * @author lukasbischof
+ *
+ */
 public class Index2D {
 	private int x;
 	private int y;

src/logic/LinearFunction.java

@@ -2,10 +2,20 @@
 
 import logic.graph.Point;
 
+/**
+ * Eine lineare Funktion
+ * @author lukasbischof
+ *
+ */
 public class LinearFunction {
 	private float m;
 	private float c;
 
+	/**
+	 * Eine Funktion erstellen, die durch die Punkte p1 und p2 geht
+	 * @param p1 Der erste Schnittpunkt
+	 * @param p2 Der zweite Schnittpunkt
+	 */
 	public LinearFunction(Point p1, Point p2) {
 		float deltaY = (float)(p2.getY() - p1.getY());
 		float deltaX = (float)(p2.getX() - p1.getX());
@@ -20,13 +30,23 @@ protected LinearFunction(float m, float c) {
 		this.c = c;
 	}
 
+	/**
+	 * Gibt eine lineare Funktion zurück, die rechtwinklig zu diese Funktion ist und durch den Punkt interception geht.
+	 * @param interception
+	 * @return
+	 */
 	public LinearFunction getPerpendicularFunction(Point interception) {
 		float newM = -(1.0f / this.m);
 		float newC = (float)(interception.getY() - newM * interception.getX());
 
 		return new LinearFunction(newM, newC);
 	}
 
+	/**
+	 * Gibt den Schnittpunkt zwischen dieser Funktion und der gegebenen Funktion zurück
+	 * @param secondFunction Die andere Funktion
+	 * @return Der Schnittpunkt
+	 */
 	public Point getInterceptionPoint(LinearFunction secondFunction) {
 		if (secondFunction.getM() == this.getM()) { // Die Funktionen sind parallel => Entweder keine oder unendlich viele Schnittpunkte
 			return null;

src/logic/Quad.java

@@ -1,5 +1,10 @@
 package logic;
 
+/**
+ * Repräsentiert ein Quadrat auf dem Spielfeld. Dies kann entweder ein freies Feld oder ein Hindernis sein.
+ * @author lukasbischof
+ *
+ */
 public class Quad {
 	private Index2D index;
 	private boolean isObstacle;

src/logic/QuadController.java

@@ -9,6 +9,11 @@ final class Constants {
 	public static float OBSTACLE_CORNER_NODE_PADDING = 0.2f;
 }
 
+/**
+ * Diese Klasse repräsentiert das Spielfeld
+ * @author lukasbischof
+ *
+ */
 public class QuadController {
 	private ArrayList<Quad> quads = new ArrayList<>();
 	private int width;
@@ -32,6 +37,12 @@ public QuadController(int width, int height) {
 		}
 	}
 
+	/**
+	 * Testet, ob zwischen dem start und dem endpunkt ein Hindernis liegt
+	 * @param start Der Startpunkt
+	 * @param end Der Endpunkt
+	 * @return Ein bool ob ein Hindernis dazwischen ist.
+	 */
 	public boolean testLineForObstacles(Point start, Point end) {
 		if (start.getX() <= 0 || end.getX() <= 0 ||
 			start.getX() >= 1 || end.getX() >= 1 ||

src/logic/graph/Point.java

@@ -2,6 +2,13 @@
 
 import logic.Index2D;
 
+/**
+ * 
+ * @author lukas bischof
+ * @class Point
+ * @description Die Klasse Point repräsentiert einen Punkt auf dem Feld. Damit er auf jede grösse des Fensters skalierbar ist,
+ * wurde x auf 0-1 und y auf 0-1 "beschränkt".
+ */
 public class Point {
 	private double x;
 	private double y;
@@ -40,6 +47,11 @@ public void setY(double y) {
 		this.y = y;
 	}
 
+	/**
+	 * Konvertierung zu einem zweidimensionalem Index
+	 * @param fieldSize Die grösse des Feldes in anzahl Blocks pro Zeile/Spalte
+	 * @return Der index
+	 */
 	public Index2D toIndex2d(double fieldSize) {
 		return new Index2D((int)Math.floor(x * fieldSize), (int)Math.floor(y * fieldSize));
 	}

src/main/Main.java

@@ -6,6 +6,8 @@
 
 public class Main {
 	public static void main(String[] args) {
+		// Test-main methode
+
 		int[][] field = new int[][] {
 			// Bottom
 			{ 0, 0, 0, 0, 0, 0, 0, 0 },