Code.md

@@ -675,7 +675,7 @@ Schlussendlich entsteht ein solches Labyrinth:
 <hr>
 
 # MazeConverter <a name="mazeconverter">
-Auch wenn diese Klasse nur sehr kurz ist, hat sie es in sich. Statt eine MiniMap hinzuzufügen, haben wir uns dazu entscheiden ein MazeConverter zu erstellen, welcher die Spielkarte zu einem Bild konvertiert. Daher kann ein Spieler nach beenden des Spieles, egal ob er gewonnen oder verloren hat, sich die Karte als .png Datei runterladen und ansehen. Die MiniMap haben wir gelassen, weil diese das Spiel viel zu leicht machen würde, da der Spieler weiß, wo er hinzugehen muss. Doch wie funktioniert diese Klasse nun?
+Auch wenn diese Klasse nur sehr kurz ist, hat sie es in sich. Statt eine MiniMap hinzuzufügen, haben wir uns dazu entscheiden ein MazeConverter zu erstellen, welcher die Spielkarte zu einem Bild konvertiert. Daher kann ein Spieler nach Beenden des Spieles, egal ob er gewonnen oder verloren hat, sich die Karte als .png Datei runterladen und ansehen. Die MiniMap haben wir weggelassen, weil diese das Spiel viel zu leicht machen würde, da der Spieler weiß, wo er entlanggehen muss. Doch wie funktioniert diese Klasse nun?
 
 ```java
 
@@ -722,7 +722,138 @@ Dieser Code bildet das Herzstück der Klasse. Nachdem der Konstruktor aufgerufen
 # Weapon <a name="weapon">
 Diese Klasse ist sehr kompliziert und leicht sogleich, wenn man alles Oben erklärte verstanden hat. Deshalb werden hier nur Tipps übergeben. Anfangen tut alles in einen normalen Konstruktor, der dieselben Werte wie die Camera zugespielt bekommt, denn wer hätte es errate, die Klasse funktioniert genau gleich. Mit einer Ausnahme: Der Konstruktor bekommt auch einen Integer namens Bullet überspielt, der später überprüft, ob der Spieler überhaupt noch Kugeln besitzt. Darauf wird die Funktion shoot() aufgerufen, wenn die Leertaste gedrückt wurde. Diese Checkt allerdings weiterhin, ob der Spieler mehr als 0 Kugeln besitzt. Dann fungiert die Funktion fast genau gleich wie die Screen-Klasse mit der Ausnahme, dass die Klasse lediglich den Sichtvektor benötigt und folglich nur einen Vektor auswürft, statt Vektoren in alle Richtungen. Dann wird wieder gecheckt, wann der Vektor und wo er auf eine Zahl größer als 1 trifft. Die 1 wurde so gewählt, weil der Spieler niemals dem Labyrinth entkommen soll, indem er sich durch die Grenz in den unendlichen Raum schießt. Deshalb bleiben die äußersten Wände auch immer in derselben Textur. Die Koordinate der Zahl wird übernommen und dann wird die Zahl gegen eine 0 ersetzt, sodass ein Loch entsteht. Darauf wird die Kugelanzahl reduziert und der Sound abgespielt.
 
-Also kann man den Code des Screens kopieren und einzelne Segmente ausradieren. Zur Ermutigung wird der Code nicht hier angegeben, sodass man es alleine ausprobieren kann und bei Verständnislücken nachgucken kann.
+<details>
+<summary>Code</summary>
+
+```java
+
+package com.s3dEngine.main;
+
+import java.util.ArrayList;
+
+public class Weapon{
+
+	public int[][] map;
+	public int mapWidth, mapHeight, width, height;
+	public ArrayList<Texture> textures;
+
+	private int bullet = 5;
+	private Sound gunSound;
+
+	public Weapon(int[][] m, int mapW, int mapH,  ArrayList<Texture> tex, int w, int h) {
+		map = m;
+		mapWidth = mapW;
+		mapHeight = mapH;
+		textures = tex;
+		width = w;
+		height = h;
+		gunSound = new Sound("Gunshot.wav");
+
+	}
+
+	public int[] update(Camera camera, int[] pixels) {
+
+		//nur wenn Space gedrckt wurde
+		if(InputHandler.shoot && bullet>=1) {
+			bullet--;
+			InputHandler.shoot = false;
+			//Position des Spielers:
+			int mapX = (int) camera.xPos;
+			int mapY = (int) camera.yPos;
+
+			//Sichtrichtung: - Double, da sonst nicht schrg schieen
+			double rayDirX = camera.xDir;
+			double rayDirY = camera.yDir;
+
+			//Schnittpunkte mit den Achsen:
+			double sideDistX;
+			double sideDistY;
+
+			//Lnge von einem Kstchen zum nchsten:
+		    double deltaDistX = Math.sqrt(1 + (rayDirY*rayDirY) / (rayDirX*rayDirX));
+		    double deltaDistY = Math.sqrt(1 + (rayDirX*rayDirX) / (rayDirY*rayDirY));
+
+		    //Distanz zur Wand (nicht schrg)
+		    double perpWallDist;
+
+		    /*
+		     * Beschreibt die Richtung des Rays - In Positive X oder negative Richtung
+		     *  x pos = 1, x neg = -1
+		     */
+		    int stepX, stepY;
+
+		    //Wand Treffer:
+		    boolean hit = false;
+
+		    //Derzeitige Achse: 0 = x-Achse
+		    int side=0;
+
+		    //Anhand des Rays stepX herausfinden:
+		    if(rayDirX < 0) {
+
+		    	stepX = -1;
+
+		    	/*SideDist ausrechnen:
+		    	 * (camera.xPos - mapX) = Dezimalzahl der x-Koordinate = Startpunkt des Rays
+		    	 */
+		    	sideDistX = (camera.xPos - mapX) * deltaDistX;
+		    }
+		    else {
+
+		    	stepX = 1;
+		    	sideDistX = (mapX + 1.0 - camera.xPos) * deltaDistX;
+		    }
+
+		    //Selbe in y-Richtung:
+		    if (rayDirY < 0)
+		    {
+		    	stepY = -1;
+		        sideDistY = (camera.yPos - mapY) * deltaDistY;
+		    }
+		    else
+		    {
+		    	stepY = 1;
+		        sideDistY = (mapY + 1.0 - camera.yPos) * deltaDistY;
+		    }
+
+		    //Nach einem Treffer an der Wand suchen:
+		    while(!hit) {
+
+		    	if(sideDistX < sideDistY) {
+
+		    		sideDistX += deltaDistX;
+		    		//Der Ray verndert seine X und Y Koordinate
+		    		mapX += stepX;
+		    		side = 0; //da x-Achse
+		    	}
+		    	else {
+
+		    		sideDistY += deltaDistY;
+		    		mapY += stepY;
+		    		side = 1;	//da y-Achse
+		    	}
+		    	//Abgleichen mit map Array
+		    	if(map[mapX][mapY] > 0) {
+		    		hit = true;	//Treffer
+		    		System.out.println("Treffer bei " + map[mapX][mapY]);
+		    		if(Game.map[mapX][mapY] > 1 && Game.map[mapX][mapY] < 5) {
+		    			Game.map[mapX][mapY] = 0;	//(int)(Math.random()*4)+1
+		    		}if(Game.map[mapX][mapY] == 5) {
+		    			Game.state = Game.STATE.FINISHED;
+		    		}
+		    	}
+
+		    }
+
+			gunSound.play();
+		}
+		return pixels;
+	}
+}
+
+```
+
+</details>
 
 # InputHandler <a name="inputhandler">