From 880b762076ea616431b8da246f794932178b1e12 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 20:27:33 +0100
Subject: [PATCH 01/14] Fehler bei ueberpuefeVertauschungen behoben

---
 .../java/projekt/enigma/model/Codierer.java   |  2 +-
 .../java/projekt/enigma/model/Steckbrett.java | 44 +++++++------------
 2 files changed, 18 insertions(+), 28 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index f62108e..bccbda4 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -408,7 +408,7 @@ public class Codierer {
 	 * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
 	 * @param port          : int : Kabel Nummer welches am Steckbrett eingesteckt wird
 	 * @param verbindung    : String : Verbindung welche die vertauschten Buchstaben angibt
-	 * @return
+	 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
 	 */
 	public boolean setSteckbrett(int port, String verbindung) {
 		return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
index f1fbfcb..02decf2 100644
--- a/src/main/java/projekt/enigma/model/Steckbrett.java
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -10,7 +10,7 @@ package projekt.enigma.model;
 public class Steckbrett {
 
 	/**
-	 * zaehler: Int, der als Laufvariable genutzt wird
+	 * zaehler: Int, der als Laufvariable für die gesteckten Kabel genutzt wird
 	 */
 	private int zaehler;
 
@@ -44,8 +44,8 @@ public class Steckbrett {
 	 * <br>
 	 * Anschließend wird:
 	 * <p>
-	 *     buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
-	 *     buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
+	 * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
+	 * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
 	 * </p>
 	 *
 	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
@@ -54,17 +54,13 @@ public class Steckbrett {
 	 */
 	public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
 
-		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
-			return false;
-		} else {
-			if (zaehler < orginalBuchstaben.length) {
-				orginalBuchstaben[zaehler] = buchstabe1;
-				getauschteBuchstaben[zaehler++] = buchstabe2;
+		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && (zaehler < orginalBuchstaben.length)) {
+			orginalBuchstaben[zaehler] = buchstabe1;
+			getauschteBuchstaben[zaehler++] = buchstabe2;
 
-				return true;
-			} else {
-				return false;
-			}
+			return true;
+		} else {
+			return false;
 		}
 	}
 
@@ -76,8 +72,8 @@ public class Steckbrett {
 	 * <br>
 	 * Anschließend wird:
 	 * <p>
-	 *     buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
-	 *     buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
+	 * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
+	 * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
 	 * </p>
 	 *
 	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
@@ -87,12 +83,13 @@ public class Steckbrett {
 	public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
 
 		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
-			return false;
-		} else {
 			orginalBuchstaben[steckbrettPort - 1] = buchstabe1;
 			getauschteBuchstaben[steckbrettPort - 1] = buchstabe2;
 
 			return true;
+		} else {
+
+			return false;
 		}
 
 	}
@@ -108,20 +105,13 @@ public class Steckbrett {
 	 * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
 	 * Wenn er schon vorhanden ist, wird true zurück gegeben
 	 */
-	public boolean ueberpruefeVertauschungen(char buchstabe) {
+	public boolean ueberpruefeVertauschungen(Character buchstabe) {
 
 		boolean result = false;
 
-		for (char c : orginalBuchstaben) {
-			if (c == buchstabe) {
-				result = true;
-				break;
-			}
-		}
-		for (char c : getauschteBuchstaben) {
-			if (c == buchstabe) {
+		for (int n = 0; n < orginalBuchstaben.length; n++) {
+			if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
 				result = true;
-				break;
 			}
 		}
 
-- 
GitLab


From bcb91f113aa30fd6ea0dc9b6b74f06be921c961c Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 20:28:25 +0100
Subject: [PATCH 02/14] Fehler bei ueberpuefeVertauschungen behoben

---
 src/main/java/projekt/enigma/model/Steckbrett.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
index 02decf2..ec18c7a 100644
--- a/src/main/java/projekt/enigma/model/Steckbrett.java
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -112,6 +112,7 @@ public class Steckbrett {
 		for (int n = 0; n < orginalBuchstaben.length; n++) {
 			if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
 				result = true;
+				break;
 			}
 		}
 
-- 
GitLab


From c2450f7f4e1badae1ebfb1be7ea3c778bc145968 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 20:40:58 +0100
Subject: [PATCH 03/14] Funktion letztesZeichenLoeschen im Codierer angelegt
 #12

---
 src/main/java/projekt/enigma/model/Codierer.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index bccbda4..b1389e0 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -464,4 +464,11 @@ public class Codierer {
 	public char[][] getSteckverbindungen() {
 		return this.codebuch.getSteckverbindung();
 	}
+
+	/**
+	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+	 */
+	public void letztesZeichenLoeschen() {
+
+	}
 }
-- 
GitLab


From bc35d2d91149c949e69ab04d5d86f70d7b57b8f7 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 22:55:28 +0100
Subject: [PATCH 04/14] Das drehen funktioniert, nur der Notch macht noch
 Probleme #12

---
 .../java/projekt/enigma/model/Codierer.java   |  13 +-
 src/main/java/projekt/enigma/model/Walze.java | 426 +++++++++---------
 2 files changed, 229 insertions(+), 210 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index b1389e0..17b1fc5 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -406,8 +406,9 @@ public class Codierer {
 
 	/**
 	 * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
-	 * @param port          : int : Kabel Nummer welches am Steckbrett eingesteckt wird
-	 * @param verbindung    : String : Verbindung welche die vertauschten Buchstaben angibt
+	 *
+	 * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
+	 * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
 	 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
 	 */
 	public boolean setSteckbrett(int port, String verbindung) {
@@ -469,6 +470,12 @@ public class Codierer {
 	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
 	 */
 	public void letztesZeichenLoeschen() {
-
+		if (this.hardware.getWalzen()[2].dreheWalze(-1)) {
+			System.out.println("Drehe W2");
+			if (this.hardware.getWalzen()[1].dreheWalze(-1)) {
+				System.out.println("Drehe W1");
+				this.hardware.getWalzen()[0].dreheWalze(-1);
+			}
+		}
 	}
 }
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index 51bf3a8..e43959f 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -1,5 +1,11 @@
 package projekt.enigma.model;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
 /**
  * Klasse Walze
  * <br>
@@ -14,10 +20,10 @@ package projekt.enigma.model;
  */
 public class Walze {
 
-    /**
-     * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
-     */
-    private Character[] alphabet;
+	/**
+	 * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+	 */
+	private Character[] alphabet;
 
 	/**
 	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
@@ -25,244 +31,250 @@ public class Walze {
 	private char ringstellung;
 
 	/**
-	 *  walzennr : int : Bestimmt, welche Walze genutzt wird
+	 * walzennr : int : Bestimmt, welche Walze genutzt wird
 	 */
-    private int walzennr;
+	private int walzennr;
 
 	/**
-	 *  alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
-	 *  aber immer wieder ueberschrieben.
+	 * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
+	 * aber immer wieder ueberschrieben.
 	 */
-    private Character[] walzeAlpha;
-
-    /**
-     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
-     *
-     * @param walzennr     : int : Nummer der gewaehlten Walze
-     * @param ringstellung : int : Einstellung des Umsprungpunktes
-     */
-    public Walze(int walzennr, int ringstellung) {
-        this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-                                        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-        this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-                                          'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
-        this.setWalzennr(walzennr);
-        this.setRingstellung(ringstellung);
-    }
-
-    /**
-     * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
-     *
-     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
-     */
-    private Character[] walzenNummer() {
-        Character[] walze = new Character[26];
-
-        // Character-Arrays fuer die Codierung jeder Walze
-        Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y',
-                                 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
-        Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M',
-                                 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
-        Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y',
-                                 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
-        Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X',
-                                 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
-        Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L',
-                                  'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
-
-        switch (this.walzennr) {
-            case 1:
-                walze = walzeEins;
-                break;
-            case 2:
-                walze = walzeZwei;
-                break;
-            case 3:
-                walze = walzeDrei;
-                break;
-            case 4:
-                walze = walzeVier;
-                break;
-            case 5:
-                walze = walzeFuenf;
-                break;
-        }
+	private Character[] walzeAlpha;
 
-        return walze;
-    }
-
-    /**
-     * TODO: Dokumentieren
-     *
-     * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
-     */
-    public char getRingstellung() {
-        return ringstellung;
-    }
-
-    /**
-     * Setzt die Initiale Ringstellung der Walze.
-     * Es sind nur Zahlen von 1 - 26 zugelassen.
+	/**
+	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
 	 *
+	 * @param walzennr     : int : Nummer der gewaehlten Walze
+	 * @param ringstellung : int : Einstellung des Umsprungpunktes
+	 */
+	public Walze(int walzennr, int ringstellung) {
+		this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+		this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+		this.setWalzennr(walzennr);
+		this.setRingstellung(ringstellung);
+	}
+
+	/**
+	 * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
+	 *
+	 * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+	 */
+	private Character[] walzenNummer() {
+		Character[] walze = new Character[26];
+
+		// Character-Arrays fuer die Codierung jeder Walze
+		Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y',
+				'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+		Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M',
+				'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+		Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y',
+				'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+		Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X',
+				'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+		Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L',
+				'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
+
+		switch (this.walzennr) {
+			case 1:
+				walze = walzeEins;
+				break;
+			case 2:
+				walze = walzeZwei;
+				break;
+			case 3:
+				walze = walzeDrei;
+				break;
+			case 4:
+				walze = walzeVier;
+				break;
+			case 5:
+				walze = walzeFuenf;
+				break;
+		}
+
+		return walze;
+	}
+
+	/**
+	 * TODO: Dokumentieren
+	 *
+	 * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
+	 */
+	public char getRingstellung() {
+		return ringstellung;
+	}
+
+	/**
+	 * Setzt die Initiale Ringstellung der Walze.
+	 * Es sind nur Zahlen von 1 - 26 zugelassen.
+	 * <p>
 	 * Die Ringstellung wird zum char umgewandelt.
-     * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
-     *
-     * @param ringstellung : int : Punkt an dem die Walze umspringt
-     */
-    //TODO ??? Setter Ringstellung
-    public void setRingstellung(int ringstellung) {
-        if ((ringstellung > 0) && (ringstellung <= 26)) {
-            this.ringstellung = this.alphabet[ringstellung - 1];
-        } else {
-            this.ringstellung = 'Z';
-        }
-    }
+	 * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+	 *
+	 * @param ringstellung : int : Punkt an dem die Walze umspringt
+	 */
+	//TODO ??? Setter Ringstellung
+	public void setRingstellung(int ringstellung) {
+		if ((ringstellung > 0) && (ringstellung <= 26)) {
+			this.ringstellung = this.alphabet[ringstellung - 1];
+		} else {
+			this.ringstellung = 'Z';
+		}
+	}
 
-    /**
-     * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
+	/**
+	 * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
 	 * das Array alphabet mit der neuen Anordnung.
-	 *
+	 * <p>
 	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
 	 *
 	 * @param drehung : int[] : Anzahl der Drehungen
 	 * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
-     * TODO: Doku
-     */
-    public boolean dreheWalze(int... drehung) {
-        boolean checkRing = false;
-
-        // fuehrt die Verschiebung des Alphabets um eine Stelle durch
-        verschiebung();
-
-        // fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
-        if (drehung.length > 0) {
-            for (int i = 1; i < drehung[0]; i++) {
-                verschiebung();
-            }
-        }
+	 * TODO: Doku
+	 */
+	public boolean dreheWalze(int... drehung) {
+		boolean checkRing = false;
+		int richtung = 1;
 
-        // gleicht die Ringstellung mit der aktuellen Position ab
-        if (this.getPosition().equals(this.ringstellung)) {
-            checkRing = true;
-        }
+		if (drehung.length > 0 && drehung[0] < 0) {
+			richtung = -1;
+		}
+
+		// fuehrt die Verschiebung des Alphabets um eine Stelle durch
+		verschiebung(richtung);
 
-        return checkRing;
-    }
+		// fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
+		if (drehung.length > 0) {
+			for (int i = 1; i < drehung[0]; i++) {
+				verschiebung(richtung);
+			}
+		}
 
-    /**
+		// gleicht die Ringstellung mit der aktuellen Position ab
+		if (this.getPosition().equals(this.ringstellung)) {
+			checkRing = true;
+		}
+
+		return checkRing;
+	}
+
+	/**
 	 * Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet.
-     * TODO: Dokumentieren
-     */
-    private void verschiebung() {
-        Character[] neueWalze = new Character[26];
+	 *
+	 * @param richtung : int : Wenn "normal" gedreht werden soll, wird 1 übergeben, reverse entspricht dann -1
+	 *                 TODO: Dokumentieren
+	 */
+	private void verschiebung(int richtung) {
 
-        for (int index = 0; index < neueWalze.length; index++) {
-            neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index];
+		if (richtung > 0) {
+            Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
+        } else {
+            Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
         }
+	}
 
-        this.walzeAlpha = neueWalze;
-    }
+	/**
+	 * TODO: Dokumentieren // dass selbe wie getPosition
+	 * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
+	 *
+	 * @return char an der Stelle temp des Alphabets
+	 */
+	public char getAnzeige() {
+		int temp = this.fetchArrayIndex('A', this.walzeAlpha);
+		return this.alphabet[temp];
+	}
 
-    /**
-     * TODO: Dokumentieren // dass selbe wie getPosition
-     * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
+	/**
+	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
 	 *
-     * @return char an der Stelle temp des Alphabets
-     */
-    public char getAnzeige() {
-        int temp = this.fetchArrayIndex('A', this.walzeAlpha);
-        return this.alphabet[temp];
-    }
-
-    /**
-     * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
-     *
 	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
-     * @return buchstabe : char : verschluesselter Buchstabe
-     */
-    public char codiere(char buchstabe) {
+	 * @return buchstabe : char : verschluesselter Buchstabe
+	 */
+	public char codiere(char buchstabe) {
         /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die gewaehlte Codierwalze*/
-        buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
+		buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
 
-        return buchstabe;
-    }
+		return buchstabe;
+	}
 
-    /**
-     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
-     *
+	/**
+	 * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
+	 *
 	 * @param buchstabe : char : Buchstabe, der decodiert werden soll
-     * @return buchstabe : char : decodierter Buchstabe
-     */
-    public char codiere2(char buchstabe) {
+	 * @return buchstabe : char : decodierter Buchstabe
+	 */
+	public char codiere2(char buchstabe) {
         /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die (verschobene) Alphabetswalze*/
 		buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())];
 
-        return buchstabe;
-    }
+		return buchstabe;
+	}
 
-    /**
-     * TODO: Dokumentieren
-     * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
+	/**
+	 * TODO: Dokumentieren
+	 * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
 	 *
-     * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
-     * @param array : Character[] : Array, in dem der Buchstabe vorkommen soll
-     * @return result : int : index des Buchstaben
-     */
-    private int fetchArrayIndex(Character buchstabe, Character[] array) {
-        // wird mit ungueltigem Wert initialisiert
-    	int result = -1;
-
-        for (int i = 0; i < array.length; i++) {
-            if (array[i].equals(buchstabe)) {
-                result = i;
-                break;
-            }
-        }
+	 * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
+	 * @param array     : Character[] : Array, in dem der Buchstabe vorkommen soll
+	 * @return result : int : index des Buchstaben
+	 */
+	private int fetchArrayIndex(Character buchstabe, Character[] array) {
+		// wird mit ungueltigem Wert initialisiert
+		int result = -1;
 
-        return result;
-    }
-
-    /**
-     * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
-     *
-     * @param walzennr : int : Walzennummer
-     */
-    public void setWalzennr(int walzennr) {
-        if ((walzennr > 0) && (walzennr < 6)) {
-            this.walzennr = walzennr;
-        } else {
-            System.err.println("Keine gültige Walzennummer");
-        }
-    }
+		for (int i = 0; i < array.length; i++) {
+			if (array[i].equals(buchstabe)) {
+				result = i;
+				break;
+			}
+		}
+
+		return result;
+	}
 
-    /**
-     * TODO: Dokumentieren // das selbe wie getAnzeig?
+	/**
+	 * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
+	 *
+	 * @param walzennr : int : Walzennummer
+	 */
+	public void setWalzennr(int walzennr) {
+		if ((walzennr > 0) && (walzennr < 6)) {
+			this.walzennr = walzennr;
+		} else {
+			System.err.println("Keine gültige Walzennummer");
+		}
+	}
+
+	/**
+	 * TODO: Dokumentieren // das selbe wie getAnzeig?
 	 * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
-     *
-     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
-     */
-    public Character getPosition() {
-        return walzeAlpha[0];
-    }
-
-    /**
-     * 	 * TODO: Funktionsname hat sich geändert
-     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-     * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
-     *
-     * @param buchstabe : Character : Einstellung der Walze
-     */
-    public void setPosition(Character buchstabe) {
-        if (Character.isLetter(buchstabe)) {
-            buchstabe = Character.toUpperCase(buchstabe);
-            System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
-            if (buchstabe > 'A') {
-                dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
-            }
-        }
-    }
+	 *
+	 * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+	 */
+	public Character getPosition() {
+		return walzeAlpha[0];
+	}
+
+	/**
+	 * * TODO: Funktionsname hat sich geändert
+	 * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+	 * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+	 * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+	 *
+	 * @param buchstabe : Character : Einstellung der Walze
+	 */
+	public void setPosition(Character buchstabe) {
+		if (Character.isLetter(buchstabe)) {
+			buchstabe = Character.toUpperCase(buchstabe);
+			System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
+			if (buchstabe > 'A') {
+				dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
+			}
+		}
+	}
 }
-- 
GitLab


From ccb507e1346147e72448a54579de8226a2853eb1 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 23:45:11 +0100
Subject: [PATCH 05/14] Das Drehen und der Notch funktionieren jetzt closes #12

---
 .../java/projekt/enigma/model/Codierer.java   |  8 +---
 .../java/projekt/enigma/model/Hardware.java   | 18 +++++---
 src/main/java/projekt/enigma/model/Walze.java | 43 +++++--------------
 3 files changed, 25 insertions(+), 44 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index 17b1fc5..590ecf5 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -470,12 +470,6 @@ public class Codierer {
 	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
 	 */
 	public void letztesZeichenLoeschen() {
-		if (this.hardware.getWalzen()[2].dreheWalze(-1)) {
-			System.out.println("Drehe W2");
-			if (this.hardware.getWalzen()[1].dreheWalze(-1)) {
-				System.out.println("Drehe W1");
-				this.hardware.getWalzen()[0].dreheWalze(-1);
-			}
-		}
+		this.hardware.dreheWalzen(-1);
 	}
 }
diff --git a/src/main/java/projekt/enigma/model/Hardware.java b/src/main/java/projekt/enigma/model/Hardware.java
index b37ddd1..58ac078 100644
--- a/src/main/java/projekt/enigma/model/Hardware.java
+++ b/src/main/java/projekt/enigma/model/Hardware.java
@@ -67,7 +67,7 @@ public class Hardware {
 	 * @return char : Der ver/entschlüsselte Buchstabe
 	 */
 	public char codiere(char buchstabe) {
-		this.dreheWalzen();
+		this.dreheWalzen(1);
 
 		buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
 		buchstabe = this.walzen[2].codiere(buchstabe);
@@ -86,10 +86,18 @@ public class Hardware {
 	 * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
 	 * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
 	 */
-	private void dreheWalzen() {
-		if (this.walzen[2].dreheWalze()) {
-			if (this.walzen[1].dreheWalze()) {
-				this.walzen[0].dreheWalze();
+	public void dreheWalzen(int richtung) {
+		if (richtung > 0) {
+			for (int i = 0; i < richtung; i++) {
+				if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) {
+					this.walzen[0].dreheWalze(1);
+				}
+			}
+		} else {
+			for (int i = 0; i > richtung; richtung++) {
+				if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) {
+					this.walzen[0].dreheWalze(-1);
+				}
 			}
 		}
 	}
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index e43959f..dc350df 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -131,51 +131,30 @@ public class Walze {
 	 * <p>
 	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
 	 *
-	 * @param drehung : int[] : Anzahl der Drehungen
+	 * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück
 	 * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
 	 * TODO: Doku
 	 */
-	public boolean dreheWalze(int... drehung) {
+	public boolean dreheWalze(int richtung) {
 		boolean checkRing = false;
-		int richtung = 1;
 
-		if (drehung.length > 0 && drehung[0] < 0) {
-			richtung = -1;
-		}
+        if (richtung == 1) {
+            Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
+        } else {
+            richtung = -1;
+            Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
+        }
 
-		// fuehrt die Verschiebung des Alphabets um eine Stelle durch
-		verschiebung(richtung);
+        System.out.printf("W: %s R: %s\n", this.getPosition(), this.ringstellung);
 
-		// fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
-		if (drehung.length > 0) {
-			for (int i = 1; i < drehung[0]; i++) {
-				verschiebung(richtung);
-			}
-		}
-
-		// gleicht die Ringstellung mit der aktuellen Position ab
-		if (this.getPosition().equals(this.ringstellung)) {
+        // gleicht die Ringstellung mit der aktuellen Position ab
+		if (this.getPosition() + 1 == this.ringstellung) {
 			checkRing = true;
 		}
 
 		return checkRing;
 	}
 
-	/**
-	 * Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet.
-	 *
-	 * @param richtung : int : Wenn "normal" gedreht werden soll, wird 1 übergeben, reverse entspricht dann -1
-	 *                 TODO: Dokumentieren
-	 */
-	private void verschiebung(int richtung) {
-
-		if (richtung > 0) {
-            Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
-        } else {
-            Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
-        }
-	}
-
 	/**
 	 * TODO: Dokumentieren // dass selbe wie getPosition
 	 * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
-- 
GitLab


From 37744340eacda74bf4323437ad57c4d9933edb6a Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 23:54:04 +0100
Subject: [PATCH 06/14] Datei formatiert

---
 src/main/java/projekt/enigma/model/Walze.java | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index dc350df..90211ea 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -1,10 +1,7 @@
 package projekt.enigma.model;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * Klasse Walze
@@ -138,16 +135,14 @@ public class Walze {
 	public boolean dreheWalze(int richtung) {
 		boolean checkRing = false;
 
-        if (richtung == 1) {
-            Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
-        } else {
-            richtung = -1;
-            Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
-        }
-
-        System.out.printf("W: %s R: %s\n", this.getPosition(), this.ringstellung);
+		if (richtung == 1) {
+			Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
+		} else {
+			richtung = -1;
+			Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
+		}
 
-        // gleicht die Ringstellung mit der aktuellen Position ab
+		// gleicht die Ringstellung mit der aktuellen Position ab
 		if (this.getPosition() + 1 == this.ringstellung) {
 			checkRing = true;
 		}
-- 
GitLab


From 7843736d7fb338427ca61eb5d0635de412efc38e Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Fri, 29 Nov 2019 23:56:23 +0100
Subject: [PATCH 07/14] =?UTF-8?q?Unittest=20f=C3=BCr=20Walze=20korrigiert.?=
 =?UTF-8?q?=20Nach=20A=20kommt=20B=20und=20nicht=20C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/test/java/projekt/enigma/model/WalzeTest.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/java/projekt/enigma/model/WalzeTest.java b/src/test/java/projekt/enigma/model/WalzeTest.java
index 7a898dd..532244a 100644
--- a/src/test/java/projekt/enigma/model/WalzeTest.java
+++ b/src/test/java/projekt/enigma/model/WalzeTest.java
@@ -17,9 +17,9 @@ public class WalzeTest {
 	@Test
 	public void dreheWalze() {
 		Walze w = new Walze(1, 3);
-		assertFalse("false erwartet, true geliefert", w.dreheWalze(2));
+		assertFalse("false erwartet, true geliefert", w.dreheWalze(1));
 		char temp = w.getAnzeige();
-		Assert.assertEquals("C erwartet, " + temp + " zurück gegeben", 'C', temp);
+		Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp);
 	}
 
 	@Test
-- 
GitLab


From 20881cd6331c9782428a794d09917a5c9c055363 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Sat, 30 Nov 2019 00:14:03 +0100
Subject: [PATCH 08/14] Wenn keine Nachricht im Funkraum vorliegt oder diese
 Fehlerhaft ist, Fehler einblenden.

---
 src/main/java/projekt/enigma/model/Codierer.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index 590ecf5..6d8ac36 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -3,7 +3,6 @@ package projekt.enigma.model;
 import org.apache.http.HttpException;
 
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Random;
 
@@ -197,7 +196,7 @@ public class Codierer {
 		String[] nachricht = new String[4];
 		String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
 
-		if (codierteNachricht[1] != null) {
+		if (codierteNachricht.length > 2 && codierteNachricht[1].split(" ").length > 3) {
 			nachricht[0] = codierteNachricht[0];
 			nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
 			nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
@@ -214,6 +213,10 @@ public class Codierer {
 				}
 			}
 			nachricht[1] = sb.toString();
+		} else {
+			nachricht[0] = "";
+			nachricht[1] = "";
+			nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
 		}
 
 		return nachricht;
@@ -320,8 +323,6 @@ public class Codierer {
 		String[] nachricht = codierteNachricht.split(" ");
 		StringBuilder sb = new StringBuilder();
 
-		System.out.println(Arrays.toString(nachricht));
-
 		// Uhrzeit
 		sb.append(nachricht[0]).append(" ");
 
-- 
GitLab


From 06c301e980212dd913e27bda40ca4269ffec8f4e Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Sat, 30 Nov 2019 01:19:42 +0100
Subject: [PATCH 09/14] Letzter Notch Fehler behoben. Jetzt springen die Walzen
 endlich am richtigen Umsprungpunkt. #12

---
 .../java/projekt/enigma/model/Codierer.java   |  8 ++++----
 src/main/java/projekt/enigma/model/Walze.java | 20 +++++--------------
 2 files changed, 9 insertions(+), 19 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index 6d8ac36..724cb46 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -196,7 +196,7 @@ public class Codierer {
 		String[] nachricht = new String[4];
 		String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
 
-		if (codierteNachricht.length > 2 && codierteNachricht[1].split(" ").length > 3) {
+		if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
 			nachricht[0] = codierteNachricht[0];
 			nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
 			nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
@@ -260,9 +260,9 @@ public class Codierer {
 	 */
 	public char[] getWalzen() {
 		char[] walzen = new char[3];
-		walzen[0] = this.hardware.getWalzen()[0].getAnzeige();
-		walzen[1] = this.hardware.getWalzen()[1].getAnzeige();
-		walzen[2] = this.hardware.getWalzen()[2].getAnzeige();
+		walzen[0] = this.hardware.getWalzen()[0].getPosition();
+		walzen[1] = this.hardware.getWalzen()[1].getPosition();
+		walzen[2] = this.hardware.getWalzen()[2].getPosition();
 
 		return walzen;
 	}
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index 90211ea..99d4124 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -134,33 +134,23 @@ public class Walze {
 	 */
 	public boolean dreheWalze(int richtung) {
 		boolean checkRing = false;
+		int korrektorFaktor = 0;
 
 		if (richtung == 1) {
-			Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
+			Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
 		} else {
-			richtung = -1;
-			Collections.rotate(Arrays.asList(this.walzeAlpha), richtung);
+			korrektorFaktor = 1;
+			Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
 		}
 
 		// gleicht die Ringstellung mit der aktuellen Position ab
-		if (this.getPosition() + 1 == this.ringstellung) {
+		if (this.getPosition() + korrektorFaktor == this.ringstellung) {
 			checkRing = true;
 		}
 
 		return checkRing;
 	}
 
-	/**
-	 * TODO: Dokumentieren // dass selbe wie getPosition
-	 * Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
-	 *
-	 * @return char an der Stelle temp des Alphabets
-	 */
-	public char getAnzeige() {
-		int temp = this.fetchArrayIndex('A', this.walzeAlpha);
-		return this.alphabet[temp];
-	}
-
 	/**
 	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
 	 *
-- 
GitLab


From fb11a37aee5fdf5c19f7dde6f3a668393087ec5e Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Sat, 30 Nov 2019 01:34:03 +0100
Subject: [PATCH 10/14] Tests korrigiert

---
 .../projekt/enigma/model/HardwareTest.java    | 30 +++++++++----------
 .../java/projekt/enigma/model/WalzeTest.java  |  8 ++---
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/test/java/projekt/enigma/model/HardwareTest.java b/src/test/java/projekt/enigma/model/HardwareTest.java
index 742e6ab..8c1fc82 100644
--- a/src/test/java/projekt/enigma/model/HardwareTest.java
+++ b/src/test/java/projekt/enigma/model/HardwareTest.java
@@ -29,23 +29,23 @@ public class HardwareTest {
 		char result;
 		h.resetWalzen();
 		result = h.codiere('A');
-		Assert.assertEquals("Codiere: A Erwartet P, erhalten " + result, 'P', result);
+		Assert.assertEquals("Codiere: A Erwartet G, erhalten " + result, 'G', result);
 		result = h.codiere('B');
-		Assert.assertEquals("Codiere: B Erwartet R, erhalten " + result, 'R', result);
+		Assert.assertEquals("Codiere: B Erwartet H, erhalten " + result, 'H', result);
 		result = h.codiere('I');
-		Assert.assertEquals("Codiere: I Erwartet E, erhalten " + result, 'E', result);
+		Assert.assertEquals("Codiere: I Erwartet C, erhalten " + result, 'C', result);
 		result = h.codiere('F');
-		Assert.assertEquals("Codiere: F Erwartet A, erhalten " + result, 'A', result);
+		Assert.assertEquals("Codiere: F Erwartet U, erhalten " + result, 'U', result);
 
 		h.resetWalzen();
-		result = h.codiere('P');
-		Assert.assertEquals("Decodiere: P Erwartet A, erhalten " + result, 'A', result);
-		result = h.codiere('R');
-		Assert.assertEquals("Decodiere: R Erwartet B, erhalten " + result, 'B', result);
-		result = h.codiere('E');
-		Assert.assertEquals("Decodiere: E Erwartet I, erhalten " + result, 'I', result);
-		result = h.codiere('A');
-		Assert.assertEquals("Decodiere: A Erwartet F, erhalten " + result, 'F', result);
+		result = h.codiere('G');
+		Assert.assertEquals("Decodiere: G Erwartet A, erhalten " + result, 'A', result);
+		result = h.codiere('H');
+		Assert.assertEquals("Decodiere: R Erwartet H, erhalten " + result, 'B', result);
+		result = h.codiere('C');
+		Assert.assertEquals("Decodiere: C Erwartet I, erhalten " + result, 'I', result);
+		result = h.codiere('U');
+		Assert.assertEquals("Decodiere: U Erwartet F, erhalten " + result, 'F', result);
 
 		h.resetWalzen();
 		h.getSteckbrett().setzeVertauschung('B', 'G');
@@ -55,10 +55,10 @@ public class HardwareTest {
 		h.getSteckbrett().setzeVertauschung('T', 'X');
 
 		result = h.codiere('I');
-		Assert.assertEquals("Codiere: Erwartet F, erhalten " + result, 'D', result);
+		Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'F', result);
 
 		h.resetWalzen();
-		result = h.codiere('D');
-		Assert.assertEquals("Codiere: Erwartet I, erhalten " + result, 'I', result);
+		result = h.codiere('K');
+		Assert.assertEquals("Codiere: K Erwartet D, erhalten " + result, 'D', result);
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/WalzeTest.java b/src/test/java/projekt/enigma/model/WalzeTest.java
index 532244a..a53f383 100644
--- a/src/test/java/projekt/enigma/model/WalzeTest.java
+++ b/src/test/java/projekt/enigma/model/WalzeTest.java
@@ -10,7 +10,7 @@ public class WalzeTest {
 	@Test
 	public void setRingstellung() {
 		Walze w = new Walze(1, 1);
-		char temp = w.getAnzeige();
+		char temp = w.getPosition();
 		Assert.assertEquals('A', temp);
 	}
 
@@ -18,14 +18,14 @@ public class WalzeTest {
 	public void dreheWalze() {
 		Walze w = new Walze(1, 3);
 		assertFalse("false erwartet, true geliefert", w.dreheWalze(1));
-		char temp = w.getAnzeige();
+		char temp = w.getPosition();
 		Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp);
 	}
 
 	@Test
-	public void getAnzeige() {
+	public void getPosition() {
 		Walze w = new Walze(1, 1);
-		char temp = w.getAnzeige();
+		char temp = w.getPosition();
 		Assert.assertEquals('A', temp);
 	}
 
-- 
GitLab


From 929a20b3315a6f7fd04a13710713eb9229ce75f4 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Sun, 1 Dec 2019 20:58:51 +0100
Subject: [PATCH 11/14] Walzen Klasse umgeschrieben closes #14

---
 .../java/projekt/enigma/model/Codierer.java   | 920 +++++++++---------
 src/main/java/projekt/enigma/model/Walze.java | 386 +++-----
 2 files changed, 623 insertions(+), 683 deletions(-)

diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index 724cb46..58b791a 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -14,463 +14,465 @@ import java.util.Random;
  */
 public class Codierer {
 
-	/**
-	 * Der Klartext Spruchschlüssel zur codierung der Nachricht
-	 */
-	private String spruchschluessel;
-	/**
-	 * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert
-	 */
-	private String spruchschluesselCodiert;
-	/**
-	 * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum)
-	 */
-	private String kenngruppe;
-	/**
-	 * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert
-	 * und im laufe der Benutzung ergänzt
-	 */
-	private String nachricht;
-	/**
-	 * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet.
-	 */
-	private Hardware hardware;
-	/**
-	 * Im Codebuch sind die Tageswerte zu finden. Ãœber dieses Objekt kann darauf zugegriffen werden.
-	 */
-	private Codebuch codebuch;
-	/**
-	 * Der aktuelle Tagesschluessel. Dieser wird aus dem Codebuch ausgelesen und hier hinterlegt.
-	 */
-	private String tagesSchluessel;
-
-	/**
-	 * Der Konstruktor des Codierers
-	 * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert.
-	 */
-	public Codierer() {
-
-		this.nachricht = "";
-		this.spruchschluessel = "";
-		this.spruchschluesselCodiert = "";
-		this.kenngruppe = "";
-		this.codebuch = new Codebuch();
-		this.codebuch.fetchTagesschluessel();
-	}
-
-	/**
-	 * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
-	 * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
-	 * in die Hardware gebaut.
-	 * <br>
-	 * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
-	 * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
-	 * <br>
-	 * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
-	 * Codebuch Eintrag.
-	 */
-	private void initialisiereHardware() {
-
-		// Das Steckbrett initialisieren
-		Steckbrett sb = new Steckbrett();
-		char[][] verbinder = this.codebuch.getSteckverbindung();
-
-		// Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
-		for (char[] kabel : verbinder) {
-			sb.setzeVertauschung(kabel[0], kabel[1]);
-		}
-
-		// Die Hardware aus dem Koffer holen (initialisieren)
-		this.hardware = new Hardware();
-
-		// Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
-		this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]);
-		this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]);
-		this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]);
-
-		// Der Hardware das gesetzte Steckbrett zuweisen
-		this.hardware.setSteckbrett(sb);
-
-		// Ein Reflektor Objekt erstellen und der Hardware bekannt geben
-		this.hardware.setReflektor(new Reflektor());
-
-	}
-
-	/**
-	 * Hier wird ein neuer Spruchschlüssel generiert.
-	 * <p>
-	 * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
-	 * Tagesschlüssel codiert, hinzugefügt.
-	 * <br>
-	 * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert,
-	 * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist.
-	 * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt.
-	 * <br>
-	 * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat.
-	 */
-	public void generateSpruchschluessel() {
-
-		String klartext = "";
-
-		while (klartext.length() < 3) {
-			String temp = this.randomBuchstabe();
-			if (!klartext.contains(temp)) {
-				klartext += temp;
-			}
-		}
-
-		this.spruchschluessel = klartext;
-		this.spruchschluesselCodiert = this.codiere(klartext + klartext, false);
-
-		// Walzen auf den Spruchschlüssel stellen
-		this.hardware.setzePosition(0, this.spruchschluessel.charAt(0));
-		this.hardware.setzePosition(1, this.spruchschluessel.charAt(1));
-		this.hardware.setzePosition(2, this.spruchschluessel.charAt(2));
-
-		// Die Kenngruppe codieren und in der Nachricht speichern
-		this.codiere(this.kenngruppe, true);
-	}
-
-	/**
-	 * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
-	 * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
-	 *
-	 * @return String : Der klartext Spruchschlüssel
-	 */
-	public String getSpruchschluessel() {
-		return this.spruchschluessel;
-	}
-
-	/**
-	 * Erstellen des Nachrichten Kopfes.
-	 * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den
-	 * Tagescodes codierte, Spruchschlüssel.
-	 */
-	private String generateKopf() {
-		Calendar cal = Calendar.getInstance();
-
-		// Uhrzeit an den Kopf hängen
-		return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " +
-
-				// Zeichen Anzahl der Nachricht
-				this.nachricht.length() + " " +
-
-				// Spruchschlüssel anhängen
-				this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " ";
-	}
-
-	/**
-	 * Einen zufälligen Buchstaben aus dem Alphabet generieren.
-	 * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind.
-	 * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben.
-	 *
-	 * @return String : ein zufällig generierter Buchstabe
-	 */
-	private String randomBuchstabe() {
-		return String.valueOf((char) ('A' + new Random().nextInt(26)));
-	}
-
-	/**
-	 * Befehl die Nachricht an den Funker zu übergeben
-	 *
-	 * @throws IOException   : Die Antwort konnte nicht gelesen werden
-	 * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
-	 */
-	public void sendeNachricht() throws IOException, HttpException {
-		String kopf = this.generateKopf();
-		new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
-		this.nachricht = "";
-	}
-
-	/**
-	 * Gibt die letzte empfangene Nachricht zurück
-	 * <br>
-	 * String[0] Tag wann die Nachricht gesendet wurde
-	 * String[1] = Die verschlüsselte Nachricht
-	 * String[2] = Nachricht im Klartext
-	 */
-	public String[] empfangeNachricht() {
-
-		this.nachricht = "";
-		Morsecode mc = new Morsecode();
-		String[] nachricht = new String[4];
-		String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
-
-		if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
-			nachricht[0] = codierteNachricht[0];
-			nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
-			nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
-			StringBuilder sb = new StringBuilder();
-
-			sb.append(nachricht[1], 0, 16);
-			for (int i = 17; i <= nachricht[1].length(); ) {
-				if ((i + 5) < nachricht[1].length()) {
-					sb.append(nachricht[1], i, i + 5).append(" ");
-					i += 5;
-				} else {
-					sb.append(nachricht[1].substring(i));
-					break;
-				}
-			}
-			nachricht[1] = sb.toString();
-		} else {
-			nachricht[0] = "";
-			nachricht[1] = "";
-			nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
-		}
-
-		return nachricht;
-	}
-
-	/**
-	 * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
-	 * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
-	 *
-	 * @return String : Kenngruppe
-	 */
-	public String getKenngruppe() {
-		return kenngruppe;
-	}
-
-	/**
-	 * Setzt die Kenngruppe welche die Enigma gerade benutzt.
-	 *
-	 * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
-	 */
-	public void setKenngruppe(String kenngruppe) {
-
-		this.kenngruppe = kenngruppe;
-		this.initialisiereHardware();
-
-	}
-
-	/**
-	 * Gibt die bisher erstellte Nachricht zurück
-	 *
-	 * @return String : Erstellte Nachricht
-	 */
-	public String getNachricht() {
-		return nachricht;
-	}
-
-	/**
-	 * Gibt die aktuellen Buchstaben auf den Walzen zurück
-	 *
-	 * @return char[] : Walzen Array mit der aktuellen Position
-	 */
-	public char[] getWalzen() {
-		char[] walzen = new char[3];
-		walzen[0] = this.hardware.getWalzen()[0].getPosition();
-		walzen[1] = this.hardware.getWalzen()[1].getPosition();
-		walzen[2] = this.hardware.getWalzen()[2].getPosition();
-
-		return walzen;
-	}
-
-	/**
-	 * Hier wird ein einzelner Buchstabe verschlüsselt.
-	 * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
-	 * In der Regel ist dies der Fall.
-	 *
-	 * @param buchstabe : char : Der zu codierende Buchstabe
-	 * @param save      : boolean : Nachricht speichern oder nicht
-	 * @return char     : Der codierte Buchstabe
-	 */
-	public char codiere(char buchstabe, boolean save) {
-		char codiert = this.hardware.codiere(buchstabe);
-		if (save) {
-			this.nachricht += codiert;
-		}
-
-		return codiert;
-	}
-
-	/**
-	 * Codiert den Ãœbergebenen String.
-	 * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
-	 * In der Regel ist dies der Fall.
-	 *
-	 * @param klartext : String : Der zu codierende Text
-	 * @param save     : boolean : Nachricht speichern oder nicht
-	 * @return String : Der codierte Text zusätzlich als Rückgabe
-	 */
-	public String codiere(String klartext, boolean save) {
-
-		StringBuilder sb = new StringBuilder();
-
-		for (char buchstabe : klartext.toCharArray()) {
-			sb.append(this.codiere(buchstabe, save));
-		}
-
-		return sb.toString();
-	}
-
-	/**
-	 * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht.
-	 * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum.
-	 * In der Regel ist dies der Tag des Nachrichten empfangs.
-	 *
-	 * @param codierteNachricht : String : Enigma codierte Nachricht
-	 * @param tag               : int : Tag der Nachricht
-	 * @return String : decodierte Nachricht
-	 */
-	private String decodiere(String codierteNachricht, int tag) {
-
-		// Hardware reseten und Tageseinstellungen aus dem Codebuch laden
-		this.initialisiereHardware();
-		this.codebuch.fetchTagesschluessel(tag);
-
-		String[] nachricht = codierteNachricht.split(" ");
-		StringBuilder sb = new StringBuilder();
-
-		// Uhrzeit
-		sb.append(nachricht[0]).append(" ");
-
-		// Zeichen Anzahl der Nachricht
-		sb.append(nachricht[1]).append(" ");
-
-		// Spruchschlüssel
-		String spruchschluessel = this.decodiereString(nachricht[2]);
-		sb.append(spruchschluessel).append(" ");
-		sb.append(this.decodiereString(nachricht[3])).append(" ");
-
-		// Walzen neu einstellen mit dem Spruchschlüssel
-		this.hardware.setzePosition(0, spruchschluessel.charAt(0));
-		this.hardware.setzePosition(1, spruchschluessel.charAt(1));
-		this.hardware.setzePosition(2, spruchschluessel.charAt(2));
-
-		// Nachricht decodieren
-		sb.append(this.decodiereString(nachricht[4]));
-
-		return sb.toString();
-	}
-
-	/**
-	 * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen.
-	 * Der String wird dann decodiert zurück gegeben.
-	 *
-	 * @param nachricht : String : Der zu decodierende Text
-	 * @return String : Der decodierte Text
-	 */
-	private String decodiereString(String nachricht) {
-
-		StringBuilder sb = new StringBuilder();
-
-		for (char buchstabe : nachricht.toCharArray()) {
-			if (buchstabe > 0) {
-				sb.append(this.hardware.codiere(buchstabe));
-			}
-		}
-
-		return sb.toString();
-	}
-
-	/**
-	 * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
-	 */
-	public void resetHardware() {
-		this.initialisiereHardware();
-	}
-
-	/**
-	 * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
-	 * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
-	 *
-	 * @param walzenPosition : int : Nummer der Walze
-	 * @param buchstabe      : char : Buchstabe der zugewiesen soll
-	 */
-	public void setWalze(int walzenPosition, char buchstabe) {
-		this.hardware.setzePosition(walzenPosition, buchstabe);
-	}
-
-	/**
-	 * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
-	 *
-	 * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
-	 * @param umsprungPunkt  : int : Buchstabe auf dem der Notch sitzt
-	 */
-	public void setRing(int walzenPosition, int umsprungPunkt) {
-		this.hardware.setzeRing(walzenPosition, umsprungPunkt);
-	}
-
-	/**
-	 * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
-	 * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
-	 *
-	 * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
-	 * @param walzeNr        : int : Nummer der Walze die eingesetzt wird
-	 * @param ringstellung   : int : Stellung des Ringes
-	 */
-	public void setWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
-		this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
-	}
-
-	/**
-	 * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
-	 *
-	 * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
-	 * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
-	 * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
-	 */
-	public boolean setSteckbrett(int port, String verbindung) {
-		return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
-	}
-
-	/**
-	 * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
-	 * <p>
-	 * setSteckbrett ausführen mit beiden Buchstaben als String
-	 *
-	 * @param buchstabe : char : Der zuletzt eingegebene Buchstabe
-	 * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false
-	 */
-	public boolean pruefeSteckbrettPort(char buchstabe) {
-		return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe);
-	}
-
-	/**
-	 * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück.
-	 *
-	 * @param empfangeneNachricht : String : Die empfangene Nachricht als String
-	 * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde.
-	 */
-	public String empfangenerSpruchschluessel(String empfangeneNachricht) {
-		String[] nachricht = empfangeneNachricht.split(" ");
-
-		return nachricht[2];
-	}
-
-	/**
-	 * Gibt die Ringstellungen aus dem Codebuch zurück
-	 *
-	 * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
-	 */
-	public int[] fetchRingstellung() {
-		return this.codebuch.getRingstellung();
-	}
-
-	/**
-	 * Gibt die Walzennummer aus dem Codebuch zurück
-	 *
-	 * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
-	 */
-	public int[] getchWalzenNr() {
-		return this.codebuch.getWalzenlage();
-	}
-
-	/**
-	 * Gibt die Steckverbindungen aus dem Codebuch zurück
-	 *
-	 * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
-	 */
-	public char[][] getSteckverbindungen() {
-		return this.codebuch.getSteckverbindung();
-	}
-
-	/**
-	 * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
-	 */
-	public void letztesZeichenLoeschen() {
-		this.hardware.dreheWalzen(-1);
-	}
+    /**
+     * Der Klartext Spruchschlüssel zur codierung der Nachricht
+     */
+    private String spruchschluessel;
+    /**
+     * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert
+     */
+    private String spruchschluesselCodiert;
+    /**
+     * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum)
+     */
+    private String kenngruppe;
+    /**
+     * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert
+     * und im laufe der Benutzung ergänzt
+     */
+    private String nachricht;
+    /**
+     * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet.
+     */
+    private Hardware hardware;
+    /**
+     * Im Codebuch sind die Tageswerte zu finden. Ãœber dieses Objekt kann darauf zugegriffen werden.
+     */
+    private Codebuch codebuch;
+    /**
+     * Der aktuelle Tagesschluessel. Dieser wird aus dem Codebuch ausgelesen und hier hinterlegt.
+     */
+    private String tagesSchluessel;
+
+    /**
+     * Der Konstruktor des Codierers
+     * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert.
+     */
+    public Codierer() {
+
+        this.nachricht = "";
+        this.spruchschluessel = "";
+        this.spruchschluesselCodiert = "";
+        this.kenngruppe = "";
+        this.codebuch = new Codebuch();
+        this.codebuch.fetchTagesschluessel();
+    }
+
+    /**
+     * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
+     * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
+     * in die Hardware gebaut.
+     * <br>
+     * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und
+     * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben.
+     * <br>
+     * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen
+     * Codebuch Eintrag.
+     */
+    private void initialisiereHardware() {
+
+        // Das Steckbrett initialisieren
+        Steckbrett sb = new Steckbrett();
+        char[][] verbinder = this.codebuch.getSteckverbindung();
+
+        // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
+        for (char[] kabel : verbinder) {
+            sb.setzeVertauschung(kabel[0], kabel[1]);
+        }
+
+        // Die Hardware aus dem Koffer holen (initialisieren)
+        this.hardware = new Hardware();
+
+        // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
+        this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]);
+        this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]);
+        this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]);
+
+        // Der Hardware das gesetzte Steckbrett zuweisen
+        this.hardware.setSteckbrett(sb);
+
+        // Ein Reflektor Objekt erstellen und der Hardware bekannt geben
+        this.hardware.setReflektor(new Reflektor());
+
+    }
+
+    /**
+     * Hier wird ein neuer Spruchschlüssel generiert.
+     * <p>
+     * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
+     * Tagesschlüssel codiert, hinzugefügt.
+     * <br>
+     * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert,
+     * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist.
+     * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt.
+     * <br>
+     * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat.
+     */
+    public void generateSpruchschluessel() {
+
+        String klartext = "";
+
+        while (klartext.length() < 3) {
+            String temp = this.randomBuchstabe();
+            if (!klartext.contains(temp)) {
+                klartext += temp;
+            }
+        }
+
+        this.spruchschluessel = klartext;
+        this.spruchschluesselCodiert = this.codiere(klartext + klartext, false);
+
+        // Walzen auf den Spruchschlüssel stellen
+        this.hardware.setzePosition(0, this.spruchschluessel.charAt(0));
+        this.hardware.setzePosition(1, this.spruchschluessel.charAt(1));
+        this.hardware.setzePosition(2, this.spruchschluessel.charAt(2));
+
+        // Die Kenngruppe codieren und in der Nachricht speichern
+        this.codiere(this.kenngruppe, true);
+    }
+
+    /**
+     * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
+     * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
+     *
+     * @return String : Der klartext Spruchschlüssel
+     */
+    public String getSpruchschluessel() {
+        return this.spruchschluessel;
+    }
+
+    /**
+     * Erstellen des Nachrichten Kopfes.
+     * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den
+     * Tagescodes codierte, Spruchschlüssel.
+     */
+    private String generateKopf() {
+        Calendar cal = Calendar.getInstance();
+
+        // Uhrzeit an den Kopf hängen
+        return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " +
+
+                // Zeichen Anzahl der Nachricht
+                this.nachricht.length() + " " +
+
+                // Spruchschlüssel anhängen
+                this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " ";
+    }
+
+    /**
+     * Einen zufälligen Buchstaben aus dem Alphabet generieren.
+     * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind.
+     * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben.
+     *
+     * @return String : ein zufällig generierter Buchstabe
+     */
+    private String randomBuchstabe() {
+        return String.valueOf((char) ('A' + new Random().nextInt(26)));
+    }
+
+    /**
+     * Befehl die Nachricht an den Funker zu übergeben
+     *
+     * @throws IOException   : Die Antwort konnte nicht gelesen werden
+     * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
+     */
+    public void sendeNachricht() throws IOException, HttpException {
+        String kopf = this.generateKopf();
+        new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
+        this.nachricht = "";
+    }
+
+    /**
+     * Gibt die letzte empfangene Nachricht zurück
+     * <br>
+     * String[0] Tag wann die Nachricht gesendet wurde
+     * String[1] = Die verschlüsselte Nachricht
+     * String[2] = Nachricht im Klartext
+     */
+    public String[] empfangeNachricht() {
+
+        this.nachricht = "";
+        Morsecode mc = new Morsecode();
+        String[] nachricht = new String[4];
+        String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+
+        if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
+            nachricht[0] = codierteNachricht[0];
+            nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+            nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
+            StringBuilder sb = new StringBuilder();
+
+            sb.append(nachricht[1], 0, 16);
+            for (int i = 17; i <= nachricht[1].length(); ) {
+                if ((i + 5) < nachricht[1].length()) {
+                    sb.append(nachricht[1], i, i + 5).append(" ");
+                    i += 5;
+                } else {
+                    sb.append(nachricht[1].substring(i));
+                    break;
+                }
+            }
+            nachricht[1] = sb.toString();
+        } else {
+            nachricht[0] = "";
+            nachricht[1] = "";
+            nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
+        }
+
+        return nachricht;
+    }
+
+    /**
+     * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
+     * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
+     *
+     * @return String : Kenngruppe
+     */
+    public String getKenngruppe() {
+        return kenngruppe;
+    }
+
+    /**
+     * Setzt die Kenngruppe welche die Enigma gerade benutzt.
+     *
+     * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
+     */
+    public void setKenngruppe(String kenngruppe) {
+
+        this.kenngruppe = kenngruppe;
+        this.initialisiereHardware();
+
+    }
+
+    /**
+     * Gibt die bisher erstellte Nachricht zurück
+     *
+     * @return String : Erstellte Nachricht
+     */
+    public String getNachricht() {
+        return nachricht;
+    }
+
+    /**
+     * Gibt die aktuellen Buchstaben auf den Walzen zurück
+     *
+     * @return char[] : Walzen Array mit der aktuellen Position
+     */
+    public char[] getWalzen() {
+        char[] walzen = new char[3];
+        walzen[0] = this.hardware.getWalzen()[0].getPosition();
+        walzen[1] = this.hardware.getWalzen()[1].getPosition();
+        walzen[2] = this.hardware.getWalzen()[2].getPosition();
+
+        return walzen;
+    }
+
+    /**
+     * Hier wird ein einzelner Buchstabe verschlüsselt.
+     * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+     * In der Regel ist dies der Fall.
+     *
+     * @param buchstabe : char : Der zu codierende Buchstabe
+     * @param save      : boolean : Nachricht speichern oder nicht
+     * @return char     : Der codierte Buchstabe
+     */
+    public char codiere(char buchstabe, boolean save) {
+
+        char codiert = this.hardware.codiere(buchstabe);
+
+        if (save) {
+            this.nachricht += codiert;
+        }
+
+        return codiert;
+    }
+
+    /**
+     * Codiert den Ãœbergebenen String.
+     * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
+     * In der Regel ist dies der Fall.
+     *
+     * @param klartext : String : Der zu codierende Text
+     * @param save     : boolean : Nachricht speichern oder nicht
+     * @return String : Der codierte Text zusätzlich als Rückgabe
+     */
+    public String codiere(String klartext, boolean save) {
+
+        StringBuilder sb = new StringBuilder();
+
+        for (char buchstabe : klartext.toCharArray()) {
+            sb.append(this.codiere(buchstabe, save));
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht.
+     * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum.
+     * In der Regel ist dies der Tag des Nachrichten empfangs.
+     *
+     * @param codierteNachricht : String : Enigma codierte Nachricht
+     * @param tag               : int : Tag der Nachricht
+     * @return String : decodierte Nachricht
+     */
+    private String decodiere(String codierteNachricht, int tag) {
+
+        // Hardware reseten und Tageseinstellungen aus dem Codebuch laden
+        this.initialisiereHardware();
+        this.codebuch.fetchTagesschluessel(tag);
+
+        String[] nachricht = codierteNachricht.split(" ");
+        StringBuilder sb = new StringBuilder();
+
+        // Uhrzeit
+        sb.append(nachricht[0]).append(" ");
+
+        // Zeichen Anzahl der Nachricht
+        sb.append(nachricht[1]).append(" ");
+
+        // Spruchschlüssel
+        String spruchschluessel = this.decodiereString(nachricht[2]);
+        sb.append(spruchschluessel).append(" ");
+        sb.append(this.decodiereString(nachricht[3])).append(" ");
+
+        // Walzen neu einstellen mit dem Spruchschlüssel
+        this.hardware.setzePosition(0, spruchschluessel.charAt(0));
+        this.hardware.setzePosition(1, spruchschluessel.charAt(1));
+        this.hardware.setzePosition(2, spruchschluessel.charAt(2));
+
+        // Nachricht decodieren
+        sb.append(this.decodiereString(nachricht[4]));
+
+        return sb.toString();
+    }
+
+    /**
+     * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen.
+     * Der String wird dann decodiert zurück gegeben.
+     *
+     * @param nachricht : String : Der zu decodierende Text
+     * @return String : Der decodierte Text
+     */
+    private String decodiereString(String nachricht) {
+
+        StringBuilder sb = new StringBuilder();
+
+        for (char buchstabe : nachricht.toCharArray()) {
+            if (buchstabe > 0) {
+                sb.append(this.hardware.codiere(buchstabe));
+            }
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
+     */
+    public void resetHardware() {
+        this.initialisiereHardware();
+    }
+
+    /**
+     * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
+     * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
+     *
+     * @param walzenPosition : int : Nummer der Walze
+     * @param buchstabe      : char : Buchstabe der zugewiesen soll
+     */
+    public void setWalze(int walzenPosition, char buchstabe) {
+        this.hardware.setzePosition(walzenPosition, buchstabe);
+    }
+
+    /**
+     * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
+     *
+     * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
+     * @param umsprungPunkt  : int : Buchstabe auf dem der Notch sitzt
+     */
+    public void setRing(int walzenPosition, int umsprungPunkt) {
+        this.hardware.setzeRing(walzenPosition, umsprungPunkt);
+    }
+
+    /**
+     * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
+     * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
+     *
+     * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
+     * @param walzeNr        : int : Nummer der Walze die eingesetzt wird
+     * @param ringstellung   : int : Stellung des Ringes
+     */
+    public void setWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
+        this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
+    }
+
+    /**
+     * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
+     *
+     * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
+     * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
+     * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
+     */
+    public boolean setSteckbrett(int port, String verbindung) {
+        return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
+    }
+
+    /**
+     * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
+     * <p>
+     * setSteckbrett ausführen mit beiden Buchstaben als String
+     *
+     * @param buchstabe : char : Der zuletzt eingegebene Buchstabe
+     * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false
+     */
+    public boolean pruefeSteckbrettPort(char buchstabe) {
+        return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe);
+    }
+
+    /**
+     * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück.
+     *
+     * @param empfangeneNachricht : String : Die empfangene Nachricht als String
+     * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde.
+     */
+    public String empfangenerSpruchschluessel(String empfangeneNachricht) {
+        String[] nachricht = empfangeneNachricht.split(" ");
+
+        return nachricht[2];
+    }
+
+    /**
+     * Gibt die Ringstellungen aus dem Codebuch zurück
+     *
+     * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
+     */
+    public int[] fetchRingstellung() {
+        return this.codebuch.getRingstellung();
+    }
+
+    /**
+     * Gibt die Walzennummer aus dem Codebuch zurück
+     *
+     * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
+     */
+    public int[] getchWalzenNr() {
+        return this.codebuch.getWalzenlage();
+    }
+
+    /**
+     * Gibt die Steckverbindungen aus dem Codebuch zurück
+     *
+     * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
+     */
+    public char[][] getSteckverbindungen() {
+        return this.codebuch.getSteckverbindung();
+    }
+
+    /**
+     * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+     */
+    public void letztesZeichenLoeschen() {
+        this.hardware.dreheWalzen(-1);
+    }
 }
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index 99d4124..dd4628b 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -1,8 +1,5 @@
 package projekt.enigma.model;
 
-import java.util.Arrays;
-import java.util.Collections;
-
 /**
  * Klasse Walze
  * <br>
@@ -17,228 +14,169 @@ import java.util.Collections;
  */
 public class Walze {
 
-	/**
-	 * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
-	 */
-	private Character[] alphabet;
-
-	/**
-	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
-	 */
-	private char ringstellung;
-
-	/**
-	 * walzennr : int : Bestimmt, welche Walze genutzt wird
-	 */
-	private int walzennr;
-
-	/**
-	 * alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
-	 * aber immer wieder ueberschrieben.
-	 */
-	private Character[] walzeAlpha;
-
-	/**
-	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
-	 *
-	 * @param walzennr     : int : Nummer der gewaehlten Walze
-	 * @param ringstellung : int : Einstellung des Umsprungpunktes
-	 */
-	public Walze(int walzennr, int ringstellung) {
-		this.alphabet = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-		this.walzeAlpha = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-				'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
-		this.setWalzennr(walzennr);
-		this.setRingstellung(ringstellung);
-	}
-
-	/**
-	 * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
-	 *
-	 * @return walze : Character[] : gibt die gewaehlte Walze zurueck
-	 */
-	private Character[] walzenNummer() {
-		Character[] walze = new Character[26];
-
-		// Character-Arrays fuer die Codierung jeder Walze
-		Character[] walzeEins = {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y',
-				'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
-		Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M',
-				'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
-		Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y',
-				'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
-		Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X',
-				'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
-		Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L',
-				'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
-
-		switch (this.walzennr) {
-			case 1:
-				walze = walzeEins;
-				break;
-			case 2:
-				walze = walzeZwei;
-				break;
-			case 3:
-				walze = walzeDrei;
-				break;
-			case 4:
-				walze = walzeVier;
-				break;
-			case 5:
-				walze = walzeFuenf;
-				break;
-		}
-
-		return walze;
-	}
-
-	/**
-	 * TODO: Dokumentieren
-	 *
-	 * @return ringstellung : char : gibt die neue Ringstellung als char zurueck
-	 */
-	public char getRingstellung() {
-		return ringstellung;
-	}
-
-	/**
-	 * Setzt die Initiale Ringstellung der Walze.
-	 * Es sind nur Zahlen von 1 - 26 zugelassen.
-	 * <p>
-	 * Die Ringstellung wird zum char umgewandelt.
-	 * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
-	 *
-	 * @param ringstellung : int : Punkt an dem die Walze umspringt
-	 */
-	//TODO ??? Setter Ringstellung
-	public void setRingstellung(int ringstellung) {
-		if ((ringstellung > 0) && (ringstellung <= 26)) {
-			this.ringstellung = this.alphabet[ringstellung - 1];
-		} else {
-			this.ringstellung = 'Z';
-		}
-	}
-
-	/**
-	 * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
-	 * das Array alphabet mit der neuen Anordnung.
-	 * <p>
-	 * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
-	 *
-	 * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück
-	 * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
-	 * TODO: Doku
-	 */
-	public boolean dreheWalze(int richtung) {
-		boolean checkRing = false;
-		int korrektorFaktor = 0;
-
-		if (richtung == 1) {
-			Collections.rotate(Arrays.asList(this.walzeAlpha), -1);
-		} else {
-			korrektorFaktor = 1;
-			Collections.rotate(Arrays.asList(this.walzeAlpha), 1);
-		}
-
-		// gleicht die Ringstellung mit der aktuellen Position ab
-		if (this.getPosition() + korrektorFaktor == this.ringstellung) {
-			checkRing = true;
-		}
-
-		return checkRing;
-	}
-
-	/**
-	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
-	 *
-	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
-	 * @return buchstabe : char : verschluesselter Buchstabe
-	 */
-	public char codiere(char buchstabe) {
+    /**
+     * Das String Array aller bekannter aktuellen Walzen
+     */
+    String[] walzen;
+
+    /**
+     * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+     */
+    private String alphabet;
+
+    /**
+     * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
+     */
+    private char ringstellung;
+
+    /**
+     * walzennr : int : Bestimmt, welche Walze genutzt wird
+     */
+    private int walzenNr;
+
+    /**
+     * Die Anzahl der getätigten Walzen Drehungen
+     */
+    private int turns;
+
+    /**
+     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
+     *
+     * @param walzenNr     : int : Nummer der gewaehlten Walze
+     * @param ringstellung : int : Einstellung des Umsprungpunktes
+     */
+    public Walze(int walzenNr, int ringstellung) {
+
+        assert false;
+        this.walzen = new String[5];
+        this.walzen[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
+        this.walzen[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
+        this.walzen[2] = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
+        this.walzen[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
+        this.walzen[4] = "VZBRGITYUPSDNHLXAWMJQOFECK";
+        this.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+        this.turns = 0;
+
+        this.setWalzenNr(walzenNr);
+        this.setRingstellung(ringstellung);
+    }
+
+    /**
+     * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
+     *
+     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+     */
+    private String fetchWalze() {
+
+        return walzen[walzenNr];
+    }
+
+    /**
+     * Setzt die Initiale Ringstellung der Walze.
+     * Es sind nur Zahlen von 1 - 26 zugelassen.
+     * <p>
+     * Die Ringstellung wird zum char umgewandelt.
+     * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+     *
+     * @param ringstellung : int : Punkt an dem die Walze umspringt
+     */
+    public void setRingstellung(int ringstellung) {
+        if ((ringstellung > 0) && (ringstellung <= 26)) {
+            this.ringstellung = this.alphabet.charAt(ringstellung - 1);
+        } else {
+            this.ringstellung = 'Z';
+        }
+    }
+
+    /**
+     * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
+     * das Array alphabet mit der neuen Anordnung.
+     * <p>
+     * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
+     *
+     * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück
+     * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
+     * TODO: Doku
+     */
+    public boolean dreheWalze(int richtung) {
+        boolean checkRing = false;
+        int korrektorFaktor = 0;
+
+        if (richtung == 1) {
+            this.turns++;
+        } else if (richtung == -1) {
+            korrektorFaktor = 1;
+            this.turns--;
+        }
+
+        // gleicht die Ringstellung mit der aktuellen Position ab
+        if (this.getPosition() + korrektorFaktor == this.ringstellung) {
+            checkRing = true;
+        }
+
+        return checkRing;
+    }
+
+    /**
+     * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
+     *
+     * @param buchstabe : char : Buchstabe, der verschluesselt werden soll
+     * @return buchstabe : char : verschluesselter Buchstabe
+     */
+    public char codiere(char buchstabe) {
         /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die gewaehlte Codierwalze*/
-		buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)];
-
-		return buchstabe;
-	}
-
-	/**
-	 * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
-	 *
-	 * @param buchstabe : char : Buchstabe, der decodiert werden soll
-	 * @return buchstabe : char : decodierter Buchstabe
-	 */
-	public char codiere2(char buchstabe) {
+
+        return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
+    }
+
+    /**
+     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
+     *
+     * @param buchstabe : char : Buchstabe, der decodiert werden soll
+     * @return buchstabe : char : decodierter Buchstabe
+     */
+    public char codiere2(char buchstabe) {
         /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
         uebertraegt den Index auf die (verschobene) Alphabetswalze*/
-		buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())];
-
-		return buchstabe;
-	}
-
-	/**
-	 * TODO: Dokumentieren
-	 * Ermittelt den Index eines Characters in einem Array ueber eine for-Schleife
-	 *
-	 * @param buchstabe : Character : Buchstabe, dessen Index benoetigt wird
-	 * @param array     : Character[] : Array, in dem der Buchstabe vorkommen soll
-	 * @return result : int : index des Buchstaben
-	 */
-	private int fetchArrayIndex(Character buchstabe, Character[] array) {
-		// wird mit ungueltigem Wert initialisiert
-		int result = -1;
-
-		for (int i = 0; i < array.length; i++) {
-			if (array[i].equals(buchstabe)) {
-				result = i;
-				break;
-			}
-		}
-
-		return result;
-	}
-
-	/**
-	 * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
-	 *
-	 * @param walzennr : int : Walzennummer
-	 */
-	public void setWalzennr(int walzennr) {
-		if ((walzennr > 0) && (walzennr < 6)) {
-			this.walzennr = walzennr;
-		} else {
-			System.err.println("Keine gültige Walzennummer");
-		}
-	}
-
-	/**
-	 * TODO: Dokumentieren // das selbe wie getAnzeig?
-	 * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
-	 *
-	 * @return Character am Index 0 des (verschobenen) Alphabets zurueck
-	 */
-	public Character getPosition() {
-		return walzeAlpha[0];
-	}
-
-	/**
-	 * * TODO: Funktionsname hat sich geändert
-	 * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-	 * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-	 * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
-	 *
-	 * @param buchstabe : Character : Einstellung der Walze
-	 */
-	public void setPosition(Character buchstabe) {
-		if (Character.isLetter(buchstabe)) {
-			buchstabe = Character.toUpperCase(buchstabe);
-			System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
-			if (buchstabe > 'A') {
-				dreheWalze(this.fetchArrayIndex(buchstabe, this.walzeAlpha));
-			}
-		}
-	}
-}
+
+        return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) + this.turns) % 26);
+    }
+
+    /**
+     * Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
+     *
+     * @param walzenNr : int : Walzennummer
+     */
+    public void setWalzenNr(int walzenNr) {
+        if ((walzenNr > 0) && (walzenNr < 6)) {
+            this.walzenNr = walzenNr - 1;
+        } else {
+            System.err.println("Keine gültige Walzennummer");
+        }
+    }
+
+    /**
+     * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
+     *
+     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+     */
+    public Character getPosition() {
+        return this.fetchWalze().charAt(turns % 26);
+    }
+
+    /**
+     * * TODO: Funktionsname hat sich geändert
+     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+     * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+     *
+     * @param buchstabe : Character : Einstellung der Walze
+     */
+    public void setPosition(Character buchstabe) {
+        if (Character.isLetter(buchstabe)) {
+            this.turns = alphabet.indexOf(buchstabe);
+        }
+    }
+}
\ No newline at end of file
-- 
GitLab


From ff395c8eda9a82980fa447e86f3a86f337dce5e1 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Mon, 2 Dec 2019 05:12:18 +0100
Subject: [PATCH 12/14] Klasse umgeschrieben: Walzen/Steckbrett/Reflektor
 closes #14 closes #15

---
 .../java/projekt/enigma/GuiController.java    |  84 ++---
 .../java/projekt/enigma/model/Codebuch.java   |  96 +++---
 .../java/projekt/enigma/model/Codierer.java   | 317 +++++++++--------
 .../java/projekt/enigma/model/Hardware.java   | 325 +++++++++---------
 .../java/projekt/enigma/model/Reflektor.java  |  27 +-
 .../java/projekt/enigma/model/Steckbrett.java | 255 +++++++-------
 src/main/java/projekt/enigma/model/Walze.java | 128 +++----
 .../projekt/enigma/model/HardwareTest.java    |  51 +--
 .../java/projekt/enigma/model/WalzeTest.java  |   2 +-
 9 files changed, 670 insertions(+), 615 deletions(-)

diff --git a/src/main/java/projekt/enigma/GuiController.java b/src/main/java/projekt/enigma/GuiController.java
index d88fdd5..3fa825e 100644
--- a/src/main/java/projekt/enigma/GuiController.java
+++ b/src/main/java/projekt/enigma/GuiController.java
@@ -221,16 +221,16 @@ public class GuiController {
      * mit dem Werten die die Klasse Codierer zur Verfügung stellt gefüllt.
      */
     private void setzeSteckverbindungen() {
-        tfStecker1.setText(codierer.getSteckverbindungen()[0][0] + "" + codierer.getSteckverbindungen()[0][1]);
-        tfStecker2.setText(codierer.getSteckverbindungen()[1][0] + "" + codierer.getSteckverbindungen()[1][1]);
-        tfStecker3.setText(codierer.getSteckverbindungen()[2][0] + "" + codierer.getSteckverbindungen()[2][1]);
-        tfStecker4.setText(codierer.getSteckverbindungen()[3][0] + "" + codierer.getSteckverbindungen()[3][1]);
-        tfStecker5.setText(codierer.getSteckverbindungen()[4][0] + "" + codierer.getSteckverbindungen()[4][1]);
-        tfStecker6.setText(codierer.getSteckverbindungen()[5][0] + "" + codierer.getSteckverbindungen()[5][1]);
-        tfStecker7.setText(codierer.getSteckverbindungen()[6][0] + "" + codierer.getSteckverbindungen()[6][1]);
-        tfStecker8.setText(codierer.getSteckverbindungen()[7][0] + "" + codierer.getSteckverbindungen()[7][1]);
-        tfStecker9.setText(codierer.getSteckverbindungen()[8][0] + "" + codierer.getSteckverbindungen()[8][1]);
-        tfStecker10.setText(codierer.getSteckverbindungen()[9][0] + "" + codierer.getSteckverbindungen()[9][1]);
+        tfStecker1.setText(codierer.fetchSteckverbindungen()[0][0] + "" + codierer.fetchSteckverbindungen()[0][1]);
+        tfStecker2.setText(codierer.fetchSteckverbindungen()[1][0] + "" + codierer.fetchSteckverbindungen()[1][1]);
+        tfStecker3.setText(codierer.fetchSteckverbindungen()[2][0] + "" + codierer.fetchSteckverbindungen()[2][1]);
+        tfStecker4.setText(codierer.fetchSteckverbindungen()[3][0] + "" + codierer.fetchSteckverbindungen()[3][1]);
+        tfStecker5.setText(codierer.fetchSteckverbindungen()[4][0] + "" + codierer.fetchSteckverbindungen()[4][1]);
+        tfStecker6.setText(codierer.fetchSteckverbindungen()[5][0] + "" + codierer.fetchSteckverbindungen()[5][1]);
+        tfStecker7.setText(codierer.fetchSteckverbindungen()[6][0] + "" + codierer.fetchSteckverbindungen()[6][1]);
+        tfStecker8.setText(codierer.fetchSteckverbindungen()[7][0] + "" + codierer.fetchSteckverbindungen()[7][1]);
+        tfStecker9.setText(codierer.fetchSteckverbindungen()[8][0] + "" + codierer.fetchSteckverbindungen()[8][1]);
+        tfStecker10.setText(codierer.fetchSteckverbindungen()[9][0] + "" + codierer.fetchSteckverbindungen()[9][1]);
     }
 
     /**
@@ -247,9 +247,9 @@ public class GuiController {
             tfKlartext.setText(textEingabe);
             tfCodiert.setText(textCodiert);
             codierer.letztesZeichenLoeschen();
-            mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-            mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-            mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+            mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
         }
     }
 
@@ -311,9 +311,9 @@ public class GuiController {
             tfCodiert.setText(textCodiert);
 
             // Position der Walzen aktuallisieren
-            mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-            mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-            mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+            mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+            mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+            mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
         }
     }
 
@@ -418,34 +418,34 @@ public class GuiController {
         mBtnNotchPos2.setText(String.valueOf(this.codierer.fetchRingstellung()[1]));
         mBtnNotchPos3.setText(String.valueOf(this.codierer.fetchRingstellung()[2]));
         // Walzennummern anzeigen
-        mBtnWalzPos1.setText(String.valueOf(this.codierer.getchWalzenNr()[0]));
-        mBtnWalzPos2.setText(String.valueOf(this.codierer.getchWalzenNr()[1]));
-        mBtnWalzPos3.setText(String.valueOf(this.codierer.getchWalzenNr()[2]));
+        mBtnWalzPos1.setText(String.valueOf(this.codierer.fetchWalzenNr()[0]));
+        mBtnWalzPos2.setText(String.valueOf(this.codierer.fetchWalzenNr()[1]));
+        mBtnWalzPos3.setText(String.valueOf(this.codierer.fetchWalzenNr()[2]));
         // Position der Walzen anzeigen
-        mBtnStartPos1.setText(String.valueOf(this.codierer.getWalzen()[0]));
-        mBtnStartPos2.setText(String.valueOf(this.codierer.getWalzen()[1]));
-        mBtnStartPos3.setText(String.valueOf(this.codierer.getWalzen()[2]));
+        mBtnStartPos1.setText(String.valueOf(this.codierer.fetchWalzen()[0]));
+        mBtnStartPos2.setText(String.valueOf(this.codierer.fetchWalzen()[1]));
+        mBtnStartPos3.setText(String.valueOf(this.codierer.fetchWalzen()[2]));
         // Steckbrett Felder setzen
-        tfStecker1.setText(this.codierer.getSteckverbindungen()[0][0] + "" +
-                this.codierer.getSteckverbindungen()[0][1]);
-        tfStecker2.setText(this.codierer.getSteckverbindungen()[1][0] + "" +
-                this.codierer.getSteckverbindungen()[1][1]);
-        tfStecker3.setText(this.codierer.getSteckverbindungen()[2][0] + "" +
-                this.codierer.getSteckverbindungen()[2][1]);
-        tfStecker4.setText(this.codierer.getSteckverbindungen()[3][0] + "" +
-                this.codierer.getSteckverbindungen()[3][1]);
-        tfStecker5.setText(this.codierer.getSteckverbindungen()[4][0] + "" +
-                this.codierer.getSteckverbindungen()[4][1]);
-        tfStecker6.setText(this.codierer.getSteckverbindungen()[5][0] + "" +
-                this.codierer.getSteckverbindungen()[5][1]);
-        tfStecker7.setText(this.codierer.getSteckverbindungen()[6][0] + "" +
-                this.codierer.getSteckverbindungen()[6][1]);
-        tfStecker8.setText(this.codierer.getSteckverbindungen()[7][0] + "" +
-                this.codierer.getSteckverbindungen()[7][1]);
-        tfStecker9.setText(this.codierer.getSteckverbindungen()[8][0] + "" +
-                this.codierer.getSteckverbindungen()[8][1]);
-        tfStecker10.setText(this.codierer.getSteckverbindungen()[9][0] + "" +
-                this.codierer.getSteckverbindungen()[9][1]);
+        tfStecker1.setText(this.codierer.fetchSteckverbindungen()[0][0] + "" +
+                this.codierer.fetchSteckverbindungen()[0][1]);
+        tfStecker2.setText(this.codierer.fetchSteckverbindungen()[1][0] + "" +
+                this.codierer.fetchSteckverbindungen()[1][1]);
+        tfStecker3.setText(this.codierer.fetchSteckverbindungen()[2][0] + "" +
+                this.codierer.fetchSteckverbindungen()[2][1]);
+        tfStecker4.setText(this.codierer.fetchSteckverbindungen()[3][0] + "" +
+                this.codierer.fetchSteckverbindungen()[3][1]);
+        tfStecker5.setText(this.codierer.fetchSteckverbindungen()[4][0] + "" +
+                this.codierer.fetchSteckverbindungen()[4][1]);
+        tfStecker6.setText(this.codierer.fetchSteckverbindungen()[5][0] + "" +
+                this.codierer.fetchSteckverbindungen()[5][1]);
+        tfStecker7.setText(this.codierer.fetchSteckverbindungen()[6][0] + "" +
+                this.codierer.fetchSteckverbindungen()[6][1]);
+        tfStecker8.setText(this.codierer.fetchSteckverbindungen()[7][0] + "" +
+                this.codierer.fetchSteckverbindungen()[7][1]);
+        tfStecker9.setText(this.codierer.fetchSteckverbindungen()[8][0] + "" +
+                this.codierer.fetchSteckverbindungen()[8][1]);
+        tfStecker10.setText(this.codierer.fetchSteckverbindungen()[9][0] + "" +
+                this.codierer.fetchSteckverbindungen()[9][1]);
     }
     //endregion
 }
diff --git a/src/main/java/projekt/enigma/model/Codebuch.java b/src/main/java/projekt/enigma/model/Codebuch.java
index 9ded525..8971dd7 100644
--- a/src/main/java/projekt/enigma/model/Codebuch.java
+++ b/src/main/java/projekt/enigma/model/Codebuch.java
@@ -23,6 +23,7 @@ import java.time.ZoneId;
  */
 public class Codebuch {
 
+	//region Variablen
 	/**
 	 * TODO: Dokumentieren tag
 	 * tag : int : gibt den Tag an
@@ -43,7 +44,9 @@ public class Codebuch {
 	 * steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar
 	 */
 	private char[][] steckverbindung;
+	//endregion
 
+	//region Konstruktor
 	/**
 	 * Im Konstruktor werden die Standardwerte gesetzt
 	 * <p>
@@ -64,7 +67,9 @@ public class Codebuch {
 			this.steckverbindung[i][1] = 'A';
 		}
 	}
+	//endregion
 
+	//region Funktionen & Methoden
 	/**
 	 * TODO: Dokumentieren
 	 * Holt den Tagesschluessel aus dem Codebuch ab. Ist kein Tag angegeben, wird der aktuelle Tag genutzt.
@@ -143,14 +148,46 @@ public class Codebuch {
 
 		return sb.toString();
 	}
+	//endregion
 
+	//region Setter
 	/**
-	 * Gibt den Tag dieser Instanz zurück
+	 * Setzt die Steckverbindung dieser Instanz
 	 *
-	 * @return int : Tag
+	 * @param kabel : String[] :  Die Steckverbindungen die gesteckt werden sollen.
+	 *              Jeder Eintrag im Array ist ein String mit zwei Zeichen.
+	 *              Diese werden in zwei chars zerlegt und anschließend im globalen
+	 *              Array gespeichert.
 	 */
-	public int getTag() {
-		return tag;
+	private void setSteckverbindung(String[] kabel) {
+		int counter = 0;
+
+		for (String stecker : kabel) {
+			char[] verbindung = new char[2];
+			verbindung[0] = stecker.charAt(0);
+			verbindung[1] = stecker.charAt(1);
+			this.steckverbindung[counter++] = verbindung;
+		}
+	}
+
+	/**
+	 * Setzt die Walzenlage dieser Instanz
+	 *
+	 * @param position   : int : Position der Walze
+	 * @param walzenlage : int : Welche Walze wurde eingesetzt
+	 */
+	private void setWalzenlage(int position, int walzenlage) {
+		this.walzenlage[position] = walzenlage;
+	}
+
+	/**
+	 * Setzt die Ringstellung dieser Instanz
+	 *
+	 * @param position     : int : Auf welche Walze wird der Ring aufgesetzt?
+	 * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]?
+	 */
+	private void setRingstellung(int position, int ringstellung) {
+		this.ringstellung[position] = ringstellung;
 	}
 
 	/**
@@ -159,6 +196,17 @@ public class Codebuch {
 	 * @param tag : int : Tag
 	 */
 	void setTag(int tag) { this.tag = tag; }
+	//endregion
+
+	//region Getter
+	/**
+	 * Gibt den Tag dieser Instanz zurück
+	 *
+	 * @return int : Tag
+	 */
+	public int getTag() {
+		return tag;
+	}
 
 	/**
 	 * Gibt die Walzenlage dieser Instanz zurück
@@ -187,43 +235,5 @@ public class Codebuch {
 	public char[][] getSteckverbindung() {
 		return this.steckverbindung;
 	}
-
-	/**
-	 * Setzt die Steckverbindung dieser Instanz
-	 *
-	 * @param kabel : String[] :  Die Steckverbindungen die gesteckt werden sollen.
-	 *              Jeder Eintrag im Array ist ein String mit zwei Zeichen.
-	 *              Diese werden in zwei chars zerlegt und anschließend im globalen
-	 *              Array gespeichert.
-	 */
-	private void setSteckverbindung(String[] kabel) {
-		int counter = 0;
-
-		for (String stecker : kabel) {
-			char[] verbindung = new char[2];
-			verbindung[0] = stecker.charAt(0);
-			verbindung[1] = stecker.charAt(1);
-			this.steckverbindung[counter++] = verbindung;
-		}
-	}
-
-	/**
-	 * Setzt die Walzenlage dieser Instanz
-	 *
-	 * @param position   : int : Position der Walze
-	 * @param walzenlage : int : Welche Walze wurde eingesetzt
-	 */
-	private void setWalzenlage(int position, int walzenlage) {
-		this.walzenlage[position] = walzenlage;
-	}
-
-	/**
-	 * Setzt die Ringstellung dieser Instanz
-	 *
-	 * @param position     : int : Auf welche Walze wird der Ring aufgesetzt?
-	 * @param ringstellung : char : An dieser Position soll die nächste Walze weiter gedreht werden.TODO: String[] || int[]?
-	 */
-	private void setRingstellung(int position, int ringstellung) {
-		this.ringstellung[position] = ringstellung;
-	}
+	//endregion
 }
diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index 58b791a..bf1c2aa 100644
--- a/src/main/java/projekt/enigma/model/Codierer.java
+++ b/src/main/java/projekt/enigma/model/Codierer.java
@@ -14,36 +14,40 @@ import java.util.Random;
  */
 public class Codierer {
 
+    //region Variablen
     /**
      * Der Klartext Spruchschlüssel zur codierung der Nachricht
      */
     private String spruchschluessel;
+
     /**
      * Der Spruchschlüssel, mit den Tageswerten aus dem Codebuch, codiert
      */
     private String spruchschluesselCodiert;
+
     /**
      * Die Kenngruppe für die versendeten Nachrichten gedacht sind. Diese ist relevant für den Webservice (Funkraum)
      */
     private String kenngruppe;
+
     /**
      * Die Nachricht, welche der Benutzer eingibt, wird als String nachricht gespeichert
      * und im laufe der Benutzung ergänzt
      */
     private String nachricht;
+
     /**
      * Das Hardware Objekt. Hier werden alle Hardware relevanten Baugruppen gespeichert und verarbeitet.
      */
     private Hardware hardware;
+
     /**
      * Im Codebuch sind die Tageswerte zu finden. Ãœber dieses Objekt kann darauf zugegriffen werden.
      */
     private Codebuch codebuch;
-    /**
-     * Der aktuelle Tagesschluessel. Dieser wird aus dem Codebuch ausgelesen und hier hinterlegt.
-     */
-    private String tagesSchluessel;
+    //endregion
 
+    //region Konstruktor
     /**
      * Der Konstruktor des Codierers
      * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert.
@@ -57,7 +61,11 @@ public class Codierer {
         this.codebuch = new Codebuch();
         this.codebuch.fetchTagesschluessel();
     }
+    //endregion
 
+    //region Funktionen & Methoden
+
+    //region Reset & Initialisieren
     /**
      * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch Objekt
      * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
@@ -93,9 +101,81 @@ public class Codierer {
 
         // Ein Reflektor Objekt erstellen und der Hardware bekannt geben
         this.hardware.setReflektor(new Reflektor());
+    }
 
+    /**
+     * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
+     */
+    public void resetHardware() {
+        this.initialisiereHardware();
+    }
+    //endregion
+
+    //region Nachrichten handler
+    /**
+     * Befehl die Nachricht an den Funker zu übergeben
+     *
+     * @throws IOException   : Die Antwort konnte nicht gelesen werden
+     * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
+     */
+    public void sendeNachricht() throws IOException, HttpException {
+        String kopf = this.generateKopf();
+        new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
+        this.nachricht = "";
+        this.resetHardware();
     }
 
+    /**
+     * Gibt die letzte empfangene Nachricht zurück
+     * <br>
+     * String[0] Tag wann die Nachricht gesendet wurde
+     * String[1] = Die verschlüsselte Nachricht
+     * String[2] = Nachricht im Klartext
+     */
+    public String[] empfangeNachricht() {
+
+        // Alte Nachrichten Variable erstmal leeren
+        this.nachricht = "";
+        // Morsecode Objekt initialisieren
+        Morsecode mc = new Morsecode();
+        // Unser Nachrichten Array soll drei Einträge erhalten
+        String[] nachricht = new String[4];
+        // Abrufen der letzten Nachricht, für unsere Kenngruppe, aus dem Funkraum
+        String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+
+        // Prüfen ob Nachrichtenlänge > 1 und die codierte Nachricht mehr als drei Felder (" ") hat
+        if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
+            // Den Tag der Nachricht speichern
+            nachricht[0] = codierteNachricht[0];
+            // Die Nachricht von Morsecode in Buchstaben konvertieren
+            nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+            // Die Enigma Nachricht (nachricht[1]) mittels der Tageseinstellungen (nachricht[0]) decodieren
+            nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
+            // StringBuilder initialisieren
+            StringBuilder sb = new StringBuilder();
+
+            sb.append(nachricht[1], 0, 16);
+            for (int i = 17; i <= nachricht[1].length(); ) {
+                if ((i + 5) < nachricht[1].length()) {
+                    sb.append(nachricht[1], i, i + 5).append(" ");
+                    i += 5;
+                } else {
+                    sb.append(nachricht[1].substring(i));
+                    break;
+                }
+            }
+            nachricht[1] = sb.toString();
+        } else {
+            nachricht[0] = "";
+            nachricht[1] = "";
+            nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
+        }
+
+        return nachricht;
+    }
+    //endregion
+
+    //region Generatoren
     /**
      * Hier wird ein neuer Spruchschlüssel generiert.
      * <p>
@@ -131,16 +211,6 @@ public class Codierer {
         this.codiere(this.kenngruppe, true);
     }
 
-    /**
-     * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
-     * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
-     *
-     * @return String : Der klartext Spruchschlüssel
-     */
-    public String getSpruchschluessel() {
-        return this.spruchschluessel;
-    }
-
     /**
      * Erstellen des Nachrichten Kopfes.
      * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den
@@ -151,10 +221,8 @@ public class Codierer {
 
         // Uhrzeit an den Kopf hängen
         return String.format("%02d%02d", cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE)) + " " +
-
                 // Zeichen Anzahl der Nachricht
                 this.nachricht.length() + " " +
-
                 // Spruchschlüssel anhängen
                 this.spruchschluesselCodiert.substring(0, 3) + " " + this.spruchschluesselCodiert.substring(3, 6) + " ";
     }
@@ -169,88 +237,81 @@ public class Codierer {
     private String randomBuchstabe() {
         return String.valueOf((char) ('A' + new Random().nextInt(26)));
     }
+    //endregion
 
+    //region setzte Funktionen
     /**
-     * Befehl die Nachricht an den Funker zu übergeben
+     * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
+     * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
      *
-     * @throws IOException   : Die Antwort konnte nicht gelesen werden
-     * @throws HttpException : Die Nachricht konnte nicht abgesendet werden
+     * @param walzenPosition : int : Nummer der Walze
+     * @param buchstabe      : char : Buchstabe der zugewiesen soll
      */
-    public void sendeNachricht() throws IOException, HttpException {
-        String kopf = this.generateKopf();
-        new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht), this.kenngruppe);
-        this.nachricht = "";
+    public void setzeWalze(int walzenPosition, char buchstabe) {
+        this.hardware.setzePosition(walzenPosition, buchstabe);
     }
 
     /**
-     * Gibt die letzte empfangene Nachricht zurück
-     * <br>
-     * String[0] Tag wann die Nachricht gesendet wurde
-     * String[1] = Die verschlüsselte Nachricht
-     * String[2] = Nachricht im Klartext
+     * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
+     *
+     * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
+     * @param umsprungPunkt  : int : Buchstabe auf dem der Notch sitzt
      */
-    public String[] empfangeNachricht() {
-
-        this.nachricht = "";
-        Morsecode mc = new Morsecode();
-        String[] nachricht = new String[4];
-        String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
-
-        if (codierteNachricht.length > 1 && codierteNachricht[1].split(" ").length > 3) {
-            nachricht[0] = codierteNachricht[0];
-            nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
-            nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
-            StringBuilder sb = new StringBuilder();
-
-            sb.append(nachricht[1], 0, 16);
-            for (int i = 17; i <= nachricht[1].length(); ) {
-                if ((i + 5) < nachricht[1].length()) {
-                    sb.append(nachricht[1], i, i + 5).append(" ");
-                    i += 5;
-                } else {
-                    sb.append(nachricht[1].substring(i));
-                    break;
-                }
-            }
-            nachricht[1] = sb.toString();
-        } else {
-            nachricht[0] = "";
-            nachricht[1] = "";
-            nachricht[2] = "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.";
-        }
-
-        return nachricht;
+    public void setzeRing(int walzenPosition, int umsprungPunkt) {
+        this.hardware.setzeRing(walzenPosition, umsprungPunkt);
     }
 
     /**
-     * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
-     * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
+     * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
+     * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
      *
-     * @return String : Kenngruppe
+     * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
+     * @param walzeNr        : int : Nummer der Walze die eingesetzt wird
+     * @param ringstellung   : int : Stellung des Ringes
      */
-    public String getKenngruppe() {
-        return kenngruppe;
+    public void setzeWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
+        this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
     }
 
     /**
-     * Setzt die Kenngruppe welche die Enigma gerade benutzt.
+     * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
      *
-     * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
+     * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
+     * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
+     * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
      */
-    public void setKenngruppe(String kenngruppe) {
+    public boolean setzeSteckbrett(int port, String verbindung) {
+        return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
+    }
+    //endregion
 
-        this.kenngruppe = kenngruppe;
-        this.initialisiereHardware();
+    //region fetch Funktionen
 
+    /**
+     * Gibt die Ringstellungen aus dem Codebuch zurück
+     *
+     * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
+     */
+    public int[] fetchRingstellung() {
+        return this.codebuch.getRingstellung();
     }
 
     /**
-     * Gibt die bisher erstellte Nachricht zurück
+     * Gibt die Walzennummer aus dem Codebuch zurück
      *
-     * @return String : Erstellte Nachricht
+     * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
      */
-    public String getNachricht() {
-        return nachricht;
+    public int[] fetchWalzenNr() {
+        return this.codebuch.getWalzenlage();
+    }
+
+    /**
+     * Gibt die Steckverbindungen aus dem Codebuch zurück
+     *
+     * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
+     */
+    public char[][] fetchSteckverbindungen() {
+        return this.codebuch.getSteckverbindung();
     }
 
     /**
@@ -258,7 +319,7 @@ public class Codierer {
      *
      * @return char[] : Walzen Array mit der aktuellen Position
      */
-    public char[] getWalzen() {
+    public char[] fetchWalzen() {
         char[] walzen = new char[3];
         walzen[0] = this.hardware.getWalzen()[0].getPosition();
         walzen[1] = this.hardware.getWalzen()[1].getPosition();
@@ -266,7 +327,9 @@ public class Codierer {
 
         return walzen;
     }
+    //endregion
 
+    //region codierer
     /**
      * Hier wird ein einzelner Buchstabe verschlüsselt.
      * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht.
@@ -322,6 +385,7 @@ public class Codierer {
         this.initialisiereHardware();
         this.codebuch.fetchTagesschluessel(tag);
 
+        // Nachricht splitten mit whitespace als delimiter
         String[] nachricht = codierteNachricht.split(" ");
         StringBuilder sb = new StringBuilder();
 
@@ -333,6 +397,7 @@ public class Codierer {
 
         // Spruchschlüssel
         String spruchschluessel = this.decodiereString(nachricht[2]);
+
         sb.append(spruchschluessel).append(" ");
         sb.append(this.decodiereString(nachricht[3])).append(" ");
 
@@ -366,57 +431,9 @@ public class Codierer {
 
         return sb.toString();
     }
+    //endregion
 
-    /**
-     * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurück.
-     */
-    public void resetHardware() {
-        this.initialisiereHardware();
-    }
-
-    /**
-     * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (wlazenPosition)
-     * TODO: Wenn die Walzen, Notches, Kabel, etc. verändert werden, muss die bisherige Nachricht (this.nachricht) gelöscht werden.
-     *
-     * @param walzenPosition : int : Nummer der Walze
-     * @param buchstabe      : char : Buchstabe der zugewiesen soll
-     */
-    public void setWalze(int walzenPosition, char buchstabe) {
-        this.hardware.setzePosition(walzenPosition, buchstabe);
-    }
-
-    /**
-     * Setzt den Ring auf der Walze auf einen neuen Umstprungwert.
-     *
-     * @param walzenPosition : int : Walze auf die der Ring gesteckt wird
-     * @param umsprungPunkt  : int : Buchstabe auf dem der Notch sitzt
-     */
-    public void setRing(int walzenPosition, int umsprungPunkt) {
-        this.hardware.setzeRing(walzenPosition, umsprungPunkt);
-    }
-
-    /**
-     * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
-     * Mit (ringstellung) gibt man die Position des Umsprungpunktes an.
-     *
-     * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3)
-     * @param walzeNr        : int : Nummer der Walze die eingesetzt wird
-     * @param ringstellung   : int : Stellung des Ringes
-     */
-    public void setWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
-        this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
-    }
-
-    /**
-     * Setzt das Kabel in beide Ports ein und fügt es dem Steckbrett Array hinzu.
-     *
-     * @param port       : int : Kabel Nummer welches am Steckbrett eingesteckt wird
-     * @param verbindung : String : Verbindung welche die vertauschten Buchstaben angibt
-     * @return boolean : Wenn true, darf das Kabel gesteckt werden, wenn nicht, steckt da bereits schon eines
-     */
-    public boolean setSteckbrett(int port, String verbindung) {
-        return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
-    }
+    //region Sonstige
 
     /**
      * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist.
@@ -443,36 +460,58 @@ public class Codierer {
     }
 
     /**
-     * Gibt die Ringstellungen aus dem Codebuch zurück
+     * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+     */
+    public void letztesZeichenLoeschen() {
+        this.hardware.dreheWalzen(-1);
+    }
+    //endregion
+    //endregion
+
+    //region Setter
+
+    /**
+     * Setzt die Kenngruppe welche die Enigma gerade benutzt.
      *
-     * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen
+     * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt
      */
-    public int[] fetchRingstellung() {
-        return this.codebuch.getRingstellung();
+    public void setKenngruppe(String kenngruppe) {
+
+        this.kenngruppe = kenngruppe;
+        this.initialisiereHardware();
+
     }
+    //endregion
+
+    //region Getter
 
     /**
-     * Gibt die Walzennummer aus dem Codebuch zurück
+     * Gibt die bisher erstellte Nachricht zurück
      *
-     * @return int[] : Array mit den Nummern der drei eingesetzten Walzen
+     * @return String : Erstellte Nachricht
      */
-    public int[] getchWalzenNr() {
-        return this.codebuch.getWalzenlage();
+    public String getNachricht() {
+        return nachricht;
     }
 
     /**
-     * Gibt die Steckverbindungen aus dem Codebuch zurück
+     * Liest die Kenngruppe aus welche die Maschine gerade besitzt. Früher war dies eine eindeutige Nummer
+     * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
      *
-     * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett
+     * @return String : Kenngruppe
      */
-    public char[][] getSteckverbindungen() {
-        return this.codebuch.getSteckverbindung();
+    public String getKenngruppe() {
+        return kenngruppe;
     }
 
     /**
-     * Löscht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurück.
+     * Der Spruchschlüssel wird, zur internen Verwendung, auch im Klartext gespeichert.
+     * Wir brauchen diesen dann zum codieren der eigentlichen Nachricht.
+     *
+     * @return String : Der klartext Spruchschlüssel
      */
-    public void letztesZeichenLoeschen() {
-        this.hardware.dreheWalzen(-1);
+    public String getSpruchschluessel() {
+        return this.spruchschluessel;
     }
+    //endregion
 }
diff --git a/src/main/java/projekt/enigma/model/Hardware.java b/src/main/java/projekt/enigma/model/Hardware.java
index 58ac078..4fc0c5b 100644
--- a/src/main/java/projekt/enigma/model/Hardware.java
+++ b/src/main/java/projekt/enigma/model/Hardware.java
@@ -15,161 +15,174 @@ package projekt.enigma.model;
  */
 public class Hardware {
 
-	/**
-	 * TODO: Dokumentieren
-	 */
-	private Walze[] walzen;
-	private Steckbrett steckbrett;
-	private Reflektor reflektor;
-
-	/**
-	 * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
-	 * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
-	 */
-	public Hardware() {
-		this.walzen = new Walze[3];
-	}
-
-	/**
-	 * Setzt eine Walze ein
-	 *
-	 * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein
-	 * @param walzenNr : int : Die Nummer der einzusetzenden Walze
-	 */
-	public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
-		this.walzen[walze] = new Walze(walzenNr, ringstellung);
-	}
-
-	/**
-	 * Setzt den Notch der Walze
-	 *
-	 * @param walze    : int : Position der Walze
-	 * @param position : int : Umspringpunkt auf der Walze
-	 */
-	public void setzeRing(int walze, int position) {
-		this.walzen[walze].setRingstellung(position);
-	}
-
-	/**
-	 * Setzt den Startwert (position) der Walze (walze)
-	 *
-	 * @param walze     : int : Nummer der Walze
-	 * @param buchstabe : char : Buchstabe der zugewiesen soll
-	 */
-	public void setzePosition(int walze, char buchstabe) {
-		this.walzen[walze].setPosition(buchstabe);
-	}
-
-	/**
-	 * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
-	 *
-	 * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
-	 * @return char : Der ver/entschlüsselte Buchstabe
-	 */
-	public char codiere(char buchstabe) {
-		this.dreheWalzen(1);
-
-		buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
-		buchstabe = this.walzen[2].codiere(buchstabe);
-		buchstabe = this.walzen[1].codiere(buchstabe);
-		buchstabe = this.walzen[0].codiere(buchstabe);
-		buchstabe = this.reflektor.codiere(buchstabe);
-		buchstabe = this.walzen[0].codiere2(buchstabe);
-		buchstabe = this.walzen[1].codiere2(buchstabe);
-		buchstabe = this.walzen[2].codiere2(buchstabe);
-		buchstabe = this.steckbrett.codiere(buchstabe);
-
-		return buchstabe;
-	}
-
-	/**
-	 * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
-	 * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
-	 */
-	public void dreheWalzen(int richtung) {
-		if (richtung > 0) {
-			for (int i = 0; i < richtung; i++) {
-				if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) {
-					this.walzen[0].dreheWalze(1);
-				}
-			}
-		} else {
-			for (int i = 0; i > richtung; richtung++) {
-				if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) {
-					this.walzen[0].dreheWalze(-1);
-				}
-			}
-		}
-	}
-
-	/**
-	 * Gibt die verbauten Walzen Objekte zurück
-	 *
-	 * @return Walze[] : Array mit den Walzen Objekten
-	 */
-	public Walze[] getWalzen() {
-		return this.walzen;
-	}
-
-	/**
-	 * Setzt eine Walze ein und speichert das Objekt im Walzen Array
-	 *
-	 * @param position     : int : Position der Walze
-	 * @param walze        : int : Die Nummer der Walze
-	 * @param ringstellung : int : Umsprung Punkt der Walze
-	 */
-	public void setWalzen(int position, int walze, int ringstellung) {
-		this.walzen[position] = new Walze(walze, ringstellung);
-	}
-
-	/**
-	 * Gibt das Objekt des Steckbretts zurück
-	 *
-	 * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
-	 */
-	public Steckbrett getSteckbrett() {
-		return steckbrett;
-	}
-
-	/**
-	 * Setzt das übergebene Steckbrett Objekt in die Hardware ein
-	 *
-	 * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
-	 */
-	public void setSteckbrett(Steckbrett steckbrett) {
-		this.steckbrett = steckbrett;
-	}
-
-	/**
-	 * Liest den Reflektor aus und gibt ihn zurück
-	 *
-	 * @return Reflektor : Objekt des Reflektors
-	 */
-	public Reflektor getReflektor() {
-		return reflektor;
-	}
-
-	/**
-	 * Setzt den Reflektor ein.
-	 * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor.
-	 * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt,
-	 * welches ausgetauscht werden kann.
-	 *
-	 * @param reflektor : Reflektor : Das Obejtk des Reflektors
-	 */
-	public void setReflektor(Reflektor reflektor) {
-		this.reflektor = reflektor;
-	}
-
-	/**
-	 * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück.
-	 * Hierfür ist der Buchstabe "A" festgelegt.
-	 * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen.
-	 */
-	public void resetWalzen() {
-		this.getWalzen()[0].setPosition('A');
-		this.getWalzen()[1].setPosition('A');
-		this.getWalzen()[2].setPosition('A');
-	}
+    //region Variablen
+    /**
+     * TODO: Dokumentieren
+     */
+    private Walze[] walzen;
+    private Steckbrett steckbrett;
+    private Reflektor reflektor;
+    //endregion
+
+    //region Konstruktor
+    /**
+     * Im Konstruktor legen wir die Anzahl der Walzen fest welche die Hardware aufnehmen kann.
+     * Die Enigma I welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
+     */
+    public Hardware() {
+        this.walzen = new Walze[3];
+    }
+    //endregion
+
+    //region Funktionen & Methoden
+    /**
+     * Setzt eine Walze ein
+     *
+     * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein
+     * @param walzenNr : int : Die Nummer der einzusetzenden Walze
+     */
+    public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
+        this.walzen[walze] = new Walze(walzenNr, ringstellung);
+    }
+
+    /**
+     * Setzt den Notch der Walze
+     *
+     * @param walze    : int : Position der Walze
+     * @param position : int : Umspringpunkt auf der Walze
+     */
+    public void setzeRing(int walze, int position) {
+        this.walzen[walze].setRingstellung(position);
+    }
+
+    /**
+     * Setzt den Startwert (position) der Walze (walze)
+     *
+     * @param walze     : int : Nummer der Walze
+     * @param buchstabe : char : Buchstabe der zugewiesen soll
+     */
+    public void setzePosition(int walze, char buchstabe) {
+        this.walzen[walze].setPosition(buchstabe);
+    }
+
+    /**
+     * Verschlüsselt den übergebenen Buchstaben und fügt ihn der Nachricht hinzu
+     *
+     * @param buchstabe char : Der zu ver/entschlüsselnde Buchstabe
+     * @return char : Der ver/entschlüsselte Buchstabe
+     */
+    public char codiere(char buchstabe) {
+
+        buchstabe = Character.toUpperCase(buchstabe);
+        this.dreheWalzen(1);
+
+        buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
+        buchstabe = this.walzen[2].codiere(buchstabe);
+        buchstabe = this.walzen[1].codiere(buchstabe);
+        buchstabe = this.walzen[0].codiere(buchstabe);
+        buchstabe = this.reflektor.codiere(buchstabe);
+        buchstabe = this.walzen[0].codiere2(buchstabe);
+        buchstabe = this.walzen[1].codiere2(buchstabe);
+        buchstabe = this.walzen[2].codiere2(buchstabe);
+        buchstabe = this.steckbrett.codiere(buchstabe);
+
+        return buchstabe;
+    }
+
+    /**
+     * Nach jeder codierung eines Buchstabens müssen die Walzen gedreht werden.
+     * Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
+     */
+    public void dreheWalzen(int richtung) {
+        if (richtung > 0) {
+            for (int i = 0; i < richtung; i++) {
+                if (this.walzen[2].dreheWalze(1) && this.walzen[1].dreheWalze(1)) {
+                    this.walzen[0].dreheWalze(1);
+                }
+            }
+        } else {
+            for (int i = 0; i > richtung; richtung++) {
+                if (this.walzen[2].dreheWalze(-1) && this.walzen[1].dreheWalze(-1)) {
+                    this.walzen[0].dreheWalze(-1);
+                }
+            }
+        }
+    }
+
+    /**
+     * Diese Funktion setzt die Walzen auf ihren Anfangswert zurück.
+     * Hierfür ist der Buchstabe "A" festgelegt.
+     * Dies wird benötigt um zB einen neuen Spruchschlüssel einzustellen oder eine neue Nachricht zu verfassen.
+     */
+    public void resetWalzen() {
+        this.getWalzen()[0].setPosition('A');
+        this.getWalzen()[1].setPosition('A');
+        this.getWalzen()[2].setPosition('A');
+    }
+    //endregion
+
+    //region Setter
+    /**
+     * Setzt eine Walze ein und speichert das Objekt im Walzen Array
+     *
+     * @param position     : int : Position der Walze
+     * @param walze        : int : Die Nummer der Walze
+     * @param ringstellung : int : Umsprung Punkt der Walze
+     */
+    public void setWalzen(int position, int walze, int ringstellung) {
+        this.walzen[position] = new Walze(walze, ringstellung);
+    }
+
+    /**
+     * Setzt den Reflektor ein.
+     * In der Enigma I welche hier nachgebaut wird, gab es nur einen Reflektor.
+     * Spätere Versionen haten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafür erstellt,
+     * welches ausgetauscht werden kann.
+     *
+     * @param reflektor : Reflektor : Das Obejtk des Reflektors
+     */
+    public void setReflektor(Reflektor reflektor) {
+        this.reflektor = reflektor;
+    }
+
+    /**
+     * Setzt das übergebene Steckbrett Objekt in die Hardware ein
+     *
+     * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln
+     */
+    public void setSteckbrett(Steckbrett steckbrett) {
+        this.steckbrett = steckbrett;
+    }
+    //endregion
+
+    //region Getter
+
+    /**
+     * Gibt das Objekt des Steckbretts zurück
+     *
+     * @return Steckbrett : Das eingesetzte Steckbrett mit seinen Kabeln wenn eingesteckt
+     */
+    public Steckbrett getSteckbrett() {
+        return steckbrett;
+    }
+
+    /**
+     * Liest den Reflektor aus und gibt ihn zurück
+     *
+     * @return Reflektor : Objekt des Reflektors
+     */
+    public Reflektor getReflektor() {
+        return reflektor;
+    }
+
+    /**
+     * Gibt die verbauten Walzen Objekte zurück
+     *
+     * @return Walze[] : Array mit den Walzen Objekten
+     */
+    public Walze[] getWalzen() {
+        return this.walzen;
+    }
+    //endregion
 
 }
diff --git a/src/main/java/projekt/enigma/model/Reflektor.java b/src/main/java/projekt/enigma/model/Reflektor.java
index 9e5e6b1..dca6241 100644
--- a/src/main/java/projekt/enigma/model/Reflektor.java
+++ b/src/main/java/projekt/enigma/model/Reflektor.java
@@ -1,6 +1,7 @@
 package projekt.enigma.model;
 
 /**
+ * TODO: Dokumentation aktuallisieren
  * Klasse Reflektor
  * <br>
  * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
@@ -12,17 +13,6 @@ package projekt.enigma.model;
  */
 public class Reflektor {
 
-    /**
-     * WALZE_ALPHABET : konstanter Char-Array mit den Werten des Alphabeths (26 Werte)
-     */
-    private final Character[] WALZE_ALPHABET = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-
-    /**
-     * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte)
-     */
-    private final Character[] WALZE_REFLEKTOR = {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'};
-
-
     /**
      * Funktion codiere
      * <br>
@@ -33,16 +23,11 @@ public class Reflektor {
      * @return WALZE_REFLEKTOR[iPositionReflektor]: Character: Der kodierte Buchstabe aus dem Reflektor
      */
     public char codiere(Character buchstabe) {
-        int iPositionReflektor = 0;
-
-        //Ermittelt die Position des Buchstaben "buchstabe" auf der Alphabetswalze
-        for (int index = 0; index < WALZE_ALPHABET.length; index++) {
-            if (buchstabe.equals(WALZE_ALPHABET[index])) {
-                iPositionReflektor = index;
-                break;
-            }
-        }
+        // alphabet : String mit den Werten des Alphabeths (26 Werte)
+        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        // reflektor : String mit den Werten des Reflektors (26 Werte)
+        String reflektor = "EJMZALYXVBWFCRQUONTSPIKHGD";
 
-        return WALZE_REFLEKTOR[iPositionReflektor];
+        return reflektor.charAt(alphabet.indexOf(buchstabe));
     }
 }
diff --git a/src/main/java/projekt/enigma/model/Steckbrett.java b/src/main/java/projekt/enigma/model/Steckbrett.java
index ec18c7a..b2d698f 100644
--- a/src/main/java/projekt/enigma/model/Steckbrett.java
+++ b/src/main/java/projekt/enigma/model/Steckbrett.java
@@ -1,6 +1,8 @@
 package projekt.enigma.model;
 
 /**
+ * TODO: Dokumentation aktuallisieren
+ * <p>
  * Klasse Steckbrett
  * <br>
  * Das Steckbrett diente dazu Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
@@ -9,134 +11,125 @@ package projekt.enigma.model;
  */
 public class Steckbrett {
 
-	/**
-	 * zaehler: Int, der als Laufvariable für die gesteckten Kabel genutzt wird
-	 */
-	private int zaehler;
-
-	/**
-	 * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
-	 */
-	private Character[] orginalBuchstaben;
-
-	/**
-	 * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
-	 */
-	private Character[] getauschteBuchstaben;
-
-
-	/**
-	 * Konstruktor Steckbrett
-	 * <br>
-	 * Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
-	 */
-	public Steckbrett() {
-
-		orginalBuchstaben = new Character[10];
-		getauschteBuchstaben = new Character[10];
-	}
-
-	/**
-	 * Funktion setzeVertauschung
-	 * <br>
-	 * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
-	 * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
-	 * <br>
-	 * Anschließend wird:
-	 * <p>
-	 * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
-	 * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
-	 * </p>
-	 *
-	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
-	 * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
-	 * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
-	 */
-	public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
-
-		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && (zaehler < orginalBuchstaben.length)) {
-			orginalBuchstaben[zaehler] = buchstabe1;
-			getauschteBuchstaben[zaehler++] = buchstabe2;
-
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	/**
-	 * Funktion setzeVertauschung mit angabe eines Ports von 1 - 10
-	 * <br>
-	 * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port übergeben.
-	 * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
-	 * <br>
-	 * Anschließend wird:
-	 * <p>
-	 * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
-	 * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
-	 * </p>
-	 *
-	 * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
-	 * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
-	 * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
-	 */
-	public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
-
-		if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
-			orginalBuchstaben[steckbrettPort - 1] = buchstabe1;
-			getauschteBuchstaben[steckbrettPort - 1] = buchstabe2;
-
-			return true;
-		} else {
-
-			return false;
-		}
-
-	}
-
-	/**
-	 * Funktion ueberpruefeVertauschungen
-	 * <br>
-	 * Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays
-	 * (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist.
-	 * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
-	 * (ein Buchstabe nicht mehrmals vertauscht wird).
-	 *
-	 * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
-	 * Wenn er schon vorhanden ist, wird true zurück gegeben
-	 */
-	public boolean ueberpruefeVertauschungen(Character buchstabe) {
-
-		boolean result = false;
-
-		for (int n = 0; n < orginalBuchstaben.length; n++) {
-			if (buchstabe.equals(orginalBuchstaben[n]) || buchstabe.equals(getauschteBuchstaben[n])) {
-				result = true;
-				break;
-			}
-		}
-
-		return result;
-	}
-
-	/**
-	 * Funktion codiere
-	 * <br>
-	 * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
-	 *
-	 * @param buchstabe : Character : Buchstabe der codiert werden soll.
-	 * @return buchstabe : Character : Codierter Buchstabe.
-	 */
-	public char codiere(Character buchstabe) {
-		for (int index = 0; index < getauschteBuchstaben.length; index++) {
-			if (buchstabe.equals(getauschteBuchstaben[index])) {
-				buchstabe = orginalBuchstaben[index];
-			} else if (buchstabe.equals(orginalBuchstaben[index])) {
-				buchstabe = getauschteBuchstaben[index];
-			}
-		}
-
-		return buchstabe;
-	}
-
-}
+    /**
+     * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
+     */
+    private String originalBuchstaben;
+
+    /**
+     * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
+     */
+    private String getauschteBuchstaben;
+
+
+    /**
+     * Konstruktor Steckbrett
+     * <br>
+     * Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
+     */
+    public Steckbrett() {
+
+        originalBuchstaben = "";
+        getauschteBuchstaben = "";
+    }
+
+    /**
+     * Funktion setzeVertauschung
+     * <br>
+     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
+     * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+     * <br>
+     * Anschließend wird:
+     * <p>
+     * buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
+     * buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
+     * </p>
+     *
+     * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+     * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+     * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
+     */
+    public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
+
+        if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && originalBuchstaben.length() <= 20) {
+            originalBuchstaben += buchstabe1;
+            getauschteBuchstaben += buchstabe2;
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Funktion setzeVertauschung mit angabe eines Ports von 1 - 10
+     * <br>
+     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port übergeben.
+     * Zuerst wird überprüft ob einer der beiden Buchstaben bereits enthalten ist, was unzulässig wäre.
+     * <br>
+     * Anschließend wird:
+     * <p>
+     * buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
+     * buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
+     * </p>
+     *
+     * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+     * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+     * @return boolean : Wenn die Vertauschung zulässig ist, true, ansonsten false
+     */
+    public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
+
+        if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
+            originalBuchstaben.replace(originalBuchstaben.charAt(steckbrettPort), buchstabe1);
+            getauschteBuchstaben.replace(getauschteBuchstaben.charAt(steckbrettPort), buchstabe2);
+
+            return true;
+        } else {
+            return false;
+        }
+
+    }
+
+    /**
+     * Funktion ueberpruefeVertauschungen
+     * <br>
+     * Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays
+     * (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist.
+     * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
+     * (ein Buchstabe nicht mehrmals vertauscht wird).
+     *
+     * @return boolean :    Wenn false, dann darf der Buchstabe genutzt werden.
+     * Wenn er schon vorhanden ist, wird true zurück gegeben
+     */
+    public boolean ueberpruefeVertauschungen(Character buchstabe) {
+
+        boolean result = false;
+
+        if (originalBuchstaben.contains(String.valueOf(buchstabe)) ||
+                getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
+            result = true;
+        }
+
+        return result;
+    }
+
+    /**
+     * Funktion codiere
+     * <br>
+     * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
+     *
+     * @param buchstabe : Character : Buchstabe der codiert werden soll.
+     * @return buchstabe : Character : Codierter Buchstabe.
+     */
+    public char codiere(Character buchstabe) {
+
+        if (originalBuchstaben.contains(String.valueOf(buchstabe))) {
+            return getauschteBuchstaben.charAt(originalBuchstaben.indexOf(buchstabe));
+        } else if(getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
+            return originalBuchstaben.charAt(getauschteBuchstaben.indexOf(buchstabe));
+        } else {
+            return buchstabe;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index dd4628b..b4baca2 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -1,6 +1,8 @@
 package projekt.enigma.model;
 
 /**
+ * TODO: Dokumentation aktuallisieren
+ * <p>
  * Klasse Walze
  * <br>
  * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
@@ -14,13 +16,14 @@ package projekt.enigma.model;
  */
 public class Walze {
 
+    //region Variablen
     /**
      * Das String Array aller bekannter aktuellen Walzen
      */
     String[] walzen;
 
     /**
-     * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
+     * alphabet : String dass die Buchstaben des Alphabets enthaelt
      */
     private String alphabet;
 
@@ -38,7 +41,9 @@ public class Walze {
      * Die Anzahl der getätigten Walzen Drehungen
      */
     private int turns;
+    //endregion
 
+    //region Konstruktor
     /**
      * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
      *
@@ -47,7 +52,6 @@ public class Walze {
      */
     public Walze(int walzenNr, int ringstellung) {
 
-        assert false;
         this.walzen = new String[5];
         this.walzen[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
         this.walzen[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
@@ -55,39 +59,14 @@ public class Walze {
         this.walzen[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
         this.walzen[4] = "VZBRGITYUPSDNHLXAWMJQOFECK";
         this.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
         this.turns = 0;
 
         this.setWalzenNr(walzenNr);
         this.setRingstellung(ringstellung);
     }
+    //endregion
 
-    /**
-     * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
-     *
-     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
-     */
-    private String fetchWalze() {
-
-        return walzen[walzenNr];
-    }
-
-    /**
-     * Setzt die Initiale Ringstellung der Walze.
-     * Es sind nur Zahlen von 1 - 26 zugelassen.
-     * <p>
-     * Die Ringstellung wird zum char umgewandelt.
-     * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
-     *
-     * @param ringstellung : int : Punkt an dem die Walze umspringt
-     */
-    public void setRingstellung(int ringstellung) {
-        if ((ringstellung > 0) && (ringstellung <= 26)) {
-            this.ringstellung = this.alphabet.charAt(ringstellung - 1);
-        } else {
-            this.ringstellung = 'Z';
-        }
-    }
+    //region Funktionen & Methoden
 
     /**
      * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
@@ -100,19 +79,20 @@ public class Walze {
      * TODO: Doku
      */
     public boolean dreheWalze(int richtung) {
-        boolean checkRing = false;
-        int korrektorFaktor = 0;
 
-        if (richtung == 1) {
-            this.turns++;
-        } else if (richtung == -1) {
-            korrektorFaktor = 1;
-            this.turns--;
-        }
+        boolean checkRing = false;
 
-        // gleicht die Ringstellung mit der aktuellen Position ab
-        if (this.getPosition() + korrektorFaktor == this.ringstellung) {
-            checkRing = true;
+        if (richtung == -1 || richtung == 1) {
+            if (richtung == 1) {
+                this.turns++;
+            } else if (richtung == -1) {
+                this.turns--;
+            }
+
+            // gleicht die Ringstellung mit der aktuellen Position ab
+            if (this.getPosition() + richtung == this.ringstellung) {
+                checkRing = true;
+            }
         }
 
         return checkRing;
@@ -125,9 +105,6 @@ public class Walze {
      * @return buchstabe : char : verschluesselter Buchstabe
      */
     public char codiere(char buchstabe) {
-        /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und
-        uebertraegt den Index auf die gewaehlte Codierwalze*/
-
         return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
     }
 
@@ -138,10 +115,37 @@ public class Walze {
      * @return buchstabe : char : decodierter Buchstabe
      */
     public char codiere2(char buchstabe) {
-        /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und
-        uebertraegt den Index auf die (verschobene) Alphabetswalze*/
 
-        return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) + this.turns) % 26);
+        int zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns;
+        if (zwischensumme < 0) {
+            zwischensumme = this.fetchWalze().indexOf(buchstabe) - this.turns + 26;
+        }
+        return this.alphabet.charAt(zwischensumme % 26);
+    }
+
+    /**
+     * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
+     *
+     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+     */
+    public String fetchWalze() {
+
+        return walzen[walzenNr];
+    }
+    //endregion
+
+    //region Setter
+
+    /**
+     * * TODO: Funktionsname hat sich geändert
+     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+     * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+     *
+     * @param buchstabe : Character : Einstellung der Walze
+     */
+    public void setPosition(Character buchstabe) {
+        this.turns = alphabet.indexOf(buchstabe);
     }
 
     /**
@@ -158,25 +162,31 @@ public class Walze {
     }
 
     /**
-     * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
+     * Setzt die Initiale Ringstellung der Walze.
+     * Es sind nur Zahlen von 1 - 26 zugelassen.
+     * <p>
+     * Die Ringstellung wird zum char umgewandelt.
+     * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
      *
-     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
+     * @param ringstellung : int : Punkt an dem die Walze umspringt
      */
-    public Character getPosition() {
-        return this.fetchWalze().charAt(turns % 26);
+    public void setRingstellung(int ringstellung) {
+        if ((ringstellung > 0) && (ringstellung <= 26)) {
+            this.ringstellung = this.alphabet.charAt(ringstellung - 1);
+        } else {
+            this.ringstellung = 'Z';
+        }
     }
+    //endregion
 
+    //region Getter
     /**
-     * * TODO: Funktionsname hat sich geändert
-     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-     * Ist die Grundeinstellung nicht 'A', wird die Methode dreheWalze() aufgerufen.
+     * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
      *
-     * @param buchstabe : Character : Einstellung der Walze
+     * @return Character am Index 0 des (verschobenen) Alphabets zurueck
      */
-    public void setPosition(Character buchstabe) {
-        if (Character.isLetter(buchstabe)) {
-            this.turns = alphabet.indexOf(buchstabe);
-        }
+    public Character getPosition() {
+        return this.alphabet.charAt(turns % 26);
     }
+    //endregion
 }
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/HardwareTest.java b/src/test/java/projekt/enigma/model/HardwareTest.java
index 8c1fc82..d0be7f0 100644
--- a/src/test/java/projekt/enigma/model/HardwareTest.java
+++ b/src/test/java/projekt/enigma/model/HardwareTest.java
@@ -17,48 +17,53 @@ public class HardwareTest {
 
 		/*
         Walze nach der Chiffrierung
-        Alphabet    {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-        Steckbrett  {'B', 'G', 'D', 'F'}
-        Steckbrett  {'G', 'B', 'F', 'F'}
-    Walze 3    {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
-		Walze 2     {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
-		Walze 1     {'E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
-        Reflektor   {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'};
+        Alphabet    "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
+        Steckbrett  "W S L V H Y G I X A"
+        Steckbrett  "J E F B K P M Q U C"
+
+		Walze 3     "E K M F L G D Q V Z N T O W Y H X U S P A I B R C J"
+        Walze 2     "V Z B R G I T Y U P S D N H L X A W M J Q O F E C K"
+        Walze 1   	"A J D K S I R U X B L H W T M C Q G Z N P Y F V O E"
+        Reflektor   "E J M Z A L Y X V B W F C R Q U O N T S P I K H G D"
 		*/
 
 		char result;
 		h.resetWalzen();
 		result = h.codiere('A');
-		Assert.assertEquals("Codiere: A Erwartet G, erhalten " + result, 'G', result);
+		Assert.assertEquals("Codiere: A Erwartet P, erhalten " + result, 'P', result);
 		result = h.codiere('B');
-		Assert.assertEquals("Codiere: B Erwartet H, erhalten " + result, 'H', result);
+		Assert.assertEquals("Codiere: B Erwartet R, erhalten " + result, 'R', result);
 		result = h.codiere('I');
-		Assert.assertEquals("Codiere: I Erwartet C, erhalten " + result, 'C', result);
+		Assert.assertEquals("Codiere: I Erwartet E, erhalten " + result, 'E', result);
 		result = h.codiere('F');
-		Assert.assertEquals("Codiere: F Erwartet U, erhalten " + result, 'U', result);
+		Assert.assertEquals("Codiere: F Erwartet A, erhalten " + result, 'A', result);
 
 		h.resetWalzen();
-		result = h.codiere('G');
-		Assert.assertEquals("Decodiere: G Erwartet A, erhalten " + result, 'A', result);
-		result = h.codiere('H');
-		Assert.assertEquals("Decodiere: R Erwartet H, erhalten " + result, 'B', result);
-		result = h.codiere('C');
-		Assert.assertEquals("Decodiere: C Erwartet I, erhalten " + result, 'I', result);
-		result = h.codiere('U');
-		Assert.assertEquals("Decodiere: U Erwartet F, erhalten " + result, 'F', result);
+		result = h.codiere('P');
+		Assert.assertEquals("Decodiere: P Erwartet A, erhalten " + result, 'A', result);
+		result = h.codiere('R');
+		Assert.assertEquals("Decodiere: R Erwartet B, erhalten " + result, 'B', result);
+		result = h.codiere('E');
+		Assert.assertEquals("Decodiere: E Erwartet I, erhalten " + result, 'I', result);
+		result = h.codiere('A');
+		Assert.assertEquals("Decodiere: A Erwartet F, erhalten " + result, 'F', result);
 
 		h.resetWalzen();
 		h.getSteckbrett().setzeVertauschung('B', 'G');
 		h.getSteckbrett().setzeVertauschung('D', 'F');
 		h.getSteckbrett().setzeVertauschung('I', 'L');
 		h.getSteckbrett().setzeVertauschung('M', 'Q');
-		h.getSteckbrett().setzeVertauschung('T', 'X');
+		h.getSteckbrett().setzeVertauschung('N', 'X');
+		h.getSteckbrett().setzeVertauschung('K', 'Y');
+		h.getSteckbrett().setzeVertauschung('U', 'Z');
+		h.getSteckbrett().setzeVertauschung('A', 'O');
+		h.getSteckbrett().setzeVertauschung('E', 'S');
 
 		result = h.codiere('I');
-		Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'F', result);
+		Assert.assertEquals("Codiere: I Erwartet F, erhalten " + result, 'D', result);
 
 		h.resetWalzen();
-		result = h.codiere('K');
-		Assert.assertEquals("Codiere: K Erwartet D, erhalten " + result, 'D', result);
+		result = h.codiere('D');
+		Assert.assertEquals("Codiere: D Erwartet I, erhalten " + result, 'I', result);
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/projekt/enigma/model/WalzeTest.java b/src/test/java/projekt/enigma/model/WalzeTest.java
index a53f383..ce8cdbc 100644
--- a/src/test/java/projekt/enigma/model/WalzeTest.java
+++ b/src/test/java/projekt/enigma/model/WalzeTest.java
@@ -16,7 +16,7 @@ public class WalzeTest {
 
 	@Test
 	public void dreheWalze() {
-		Walze w = new Walze(1, 3);
+		Walze w = new Walze(1, 4);
 		assertFalse("false erwartet, true geliefert", w.dreheWalze(1));
 		char temp = w.getPosition();
 		Assert.assertEquals("B erwartet, " + temp + " zurück gegeben", 'B', temp);
-- 
GitLab


From 13826c63952022a2ff3a8a31c65f87fdf3d981ee Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Mon, 2 Dec 2019 05:31:00 +0100
Subject: [PATCH 13/14] Array zu String korrigiert in der Dokumentation

---
 .gitlab-ci.yml                                |  8 +++++++-
 src/main/java/projekt/enigma/model/Walze.java | 11 ++++-------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index ea3af64..9b0bfde 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -18,4 +18,10 @@ Run JUnit tests and verify:
     reports:
       junit:
       - target/surefire-reports/TEST-*.xml
-      - target/failsafe-reports/TEST-*.xml
\ No newline at end of file
+      - target/failsafe-reports/TEST-*.xml
+
+enable_merge:
+  only: merge_requests
+  script:
+    - echo true
+
diff --git a/src/main/java/projekt/enigma/model/Walze.java b/src/main/java/projekt/enigma/model/Walze.java
index b4baca2..62394ac 100644
--- a/src/main/java/projekt/enigma/model/Walze.java
+++ b/src/main/java/projekt/enigma/model/Walze.java
@@ -45,7 +45,7 @@ public class Walze {
 
     //region Konstruktor
     /**
-     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mitgibt
+     * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt
      *
      * @param walzenNr     : int : Nummer der gewaehlten Walze
      * @param ringstellung : int : Einstellung des Umsprungpunktes
@@ -67,10 +67,8 @@ public class Walze {
     //endregion
 
     //region Funktionen & Methoden
-
     /**
-     * Dreht die Walze: verschiebt das Alphabet um keine, eine oder mehrere Stellen und ueberschreibt
-     * das Array alphabet mit der neuen Anordnung.
+     * Dreht die Walze: Zählt die Umdrehungen (Turns) um eines hoch oder runter, je nach Drehrichtung.
      * <p>
      * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
      *
@@ -109,7 +107,7 @@ public class Walze {
     }
 
     /**
-     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Alphabetswalze
+     * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Walze
      *
      * @param buchstabe : char : Buchstabe, der decodiert werden soll
      * @return buchstabe : char : decodierter Buchstabe
@@ -124,7 +122,7 @@ public class Walze {
     }
 
     /**
-     * Sortiert der Walzennummer das passende Character-Array mittels switch zu.
+     * Holt den korrekten String zu der Walze
      *
      * @return walze : Character[] : gibt die gewaehlte Walze zurueck
      */
@@ -135,7 +133,6 @@ public class Walze {
     //endregion
 
     //region Setter
-
     /**
      * * TODO: Funktionsname hat sich geändert
      * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-- 
GitLab


From d8b4986675f2f3f1a7bc18f224ada36c294cc4f4 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Mon, 2 Dec 2019 05:32:16 +0100
Subject: [PATCH 14/14] Fixed .gitlab-ci.yml

---
 .gitlab-ci.yml | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 9b0bfde..ea3af64 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -18,10 +18,4 @@ Run JUnit tests and verify:
     reports:
       junit:
       - target/surefire-reports/TEST-*.xml
-      - target/failsafe-reports/TEST-*.xml
-
-enable_merge:
-  only: merge_requests
-  script:
-    - echo true
-
+      - target/failsafe-reports/TEST-*.xml
\ No newline at end of file
-- 
GitLab