src/main/java/projekt/enigma/model/Hardware.java

+package projekt.enigma.model;
+
+/**
+ * In dieser Klasse wird die Hardware zusammengefasst.
+ * Alle Komponenten der Enigma laufen hier zusammen.
+ *
+ * <p>
+ * walzen : Walze[] :           Ist ein Array der drei eingebauten Walzen Objekte
+ * steckbrett : Steckbrett :    Das Steckbrett mit den Verbindungen aus dem Codebuch
+ * reflektor : Reflektor :      Dies ist das Objekt der Reflektors
+ * nachricht : String :         Die verschluesselte Nachricht wird in diesem String zusammengesetzt und gespeichert
+ * kenngruppe : String :        Frueher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
+ * Wir missbrauchen die Kenngruppe für einen Benutzernamen
+ * </p>
+ */
+public class Hardware {
+
+	//region Variablen
+	/**
+	 * walzen: Walze-Array: erzeugt ein privates Array mit der die Anzahl der Walzen festgelegt wird.
+	 */
+	private Walze[] walzen;
+
+	/**
+	 * steckbrett: Steckbrett: erzeugt ein privates Steckbrett-Objekt
+	 */
+	private Steckbrett steckbrett;
+
+	/**
+	 * reflektor: Reflektor: erzeugt ein privates Reflektor-Objekt.
+	 */
+	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.
+     * @param ringstellung : int : Setzt den Ring der Walze auf die angegebene Nummer.
+     */
+    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 werden soll.
+     */
+    public void setzePosition(int walze, char buchstabe) {
+        this.walzen[walze].setPosition(buchstabe);
+    }
+
+    /**
+     * Verschluesselt den uebergebenen Buchstaben und fuegt ihn der Nachricht hinzu.
+     * Debug Ausgabe auf der Konsole wird zusaetzlich ausgegeben.
+     *
+     * @param buchstabe char : Der zu ver/entschluesselnde Buchstabe.
+     * @return char : Der ver/entschluesselte Buchstabe.
+     */
+    public char codiere(char buchstabe) {
+        new Fehler().debug(this.getClass().getName() + "." +
+                new Throwable().getStackTrace()[0].getMethodName(), true);
+
+        buchstabe = Character.toUpperCase(buchstabe);
+        String debug = String.format("Positionen: W1:%s W2:%s W3:%s",
+                this.walzen[0].getPosition(),
+                this.walzen[1].getPosition(),
+                this.walzen[2].getPosition());
+        debug += "\nI\tS\t3\t2\t1\tR\t1\t2\t3\tS\n" + buchstabe;
+
+		this.dreheWalzen(1);
+
+        //Codiere Vorgang wird fuer jede Walze bis zum Reflektor mit der codiere Funktion durchgefuehrt.
+        //Auf dem Rueckweg wird mit der codiere2 Funktion codiert.
+        buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[2].codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[1].codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[0].codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.reflektor.codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[0].codiere2(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[1].codiere2(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[2].codiere2(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.steckbrett.codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        new Fehler().debug(debug, false);
+
+		return buchstabe;
+	}
+
+    /**
+     * Nach jeder Codierung eines Buchstabens muessen die Walzen gedreht werden.
+     * Hier ueberpruefen wir, welche der Walzen gedreht werden muessen und stossen den Vorgang an.
+     *
+     * @param richtung : int : +1 fuer eine Vorwaertsdrehung und -1 fuer eine Rueckwaertsdrehung.
+     */
+    public void dreheWalzen(int richtung) {
+        if (richtung > 0) {
+            for (int i = 0; i < richtung; i++) {
+                if (this.walzen[2].dreheWalze(1)) {
+                    if (this.walzen[1].dreheWalze(1)) {
+                        this.walzen[0].dreheWalze(1);
+                    }
+                }
+            }
+        } else {
+            for (int i = 0; i > richtung; richtung++) {
+                if (this.walzen[2].dreheWalze(-1)) {
+                    if (this.walzen[1].dreheWalze(-1)) {
+                        this.walzen[0].dreheWalze(-1);
+                    }
+                }
+            }
+        }
+    }
+    //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 : Umsprungpunkt der Walze.
+     */
+    public void setWalzen(int position, int walze, int ringstellung) {
+        this.walzen[position] = new Walze(walze, ringstellung);
+    }
+
+    /**
+     * Gibt das Objekt des Steckbretts zurueck.
+     *
+     * @return steckbrett : Steckbrett-Objekt:  Das eingesetzte Steckbrett mit seinen Kabeln, wenn eingesteckt.
+     */
+    public Steckbrett getSteckbrett() {
+        return steckbrett;
+    }
+
+    /**
+     * Setzt das uebergebene 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
+
+    /**
+     * Setzt den Reflektor ein.
+     * In der Enigma I, welche hier nachgebaut wird, gab es nur einen Reflektor.
+     * Spaetere Versionen hatten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafuer erstellt,
+     * welches ausgetauscht werden kann.
+     *
+     * @param reflektor : Reflektor : Das Objekt des Reflektors.
+     */
+    public void setReflektor(Reflektor reflektor) {
+        this.reflektor = reflektor;
+    }
+
+    /**
+     * Gibt die verbauten Walzen Objekte zurück.
+     *
+     * @return walzen : Walze[] : Array mit den Walzen Objekten.
+     */
+    public Walze[] getWalzen() {
+        return this.walzen;
+    }
+    //endregion
+
+}

src/main/java/projekt/enigma/model/Morsecode.java

+package projekt.enigma.model;
+
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
+/**
+ * Diese Klasse definiert die Zugehoerigkeit zwischen den Buchstaben A-Z und dem Morsecode.
+ * Die Funktionen sollen Texte von und zu Morsecode konvertieren.
+ */
+public class Morsecode {
+
+    /**
+     * Anlegen der codeMap als TreeMap.
+     */
+    private TreeMap<String, String> codeMap;
+
+    /**
+     * Im Konstruktor werden alle verfuegbaren Buchstaben (A-Z) und deren zugehoerigen
+     * Morsecodes, der codeMap hinzugefuegt.
+     */
+    public Morsecode() {
+        codeMap = new TreeMap<>();
+        this.codeMap.put("A", ".-");
+        this.codeMap.put("B", "-...");
+        this.codeMap.put("C", "-.-.");
+        this.codeMap.put("D", "-..");
+        this.codeMap.put("E", ".");
+        this.codeMap.put("F", "..-.");
+        this.codeMap.put("G", "--.");
+        this.codeMap.put("H", "....");
+        this.codeMap.put("I", "..");
+        this.codeMap.put("J", ".---");
+        this.codeMap.put("K", "-.-");
+        this.codeMap.put("L", ".-..");
+        this.codeMap.put("M", "--");
+        this.codeMap.put("N", "-.");
+        this.codeMap.put("O", "---");
+        this.codeMap.put("P", ".--.");
+        this.codeMap.put("Q", "--.-");
+        this.codeMap.put("R", ".-.");
+        this.codeMap.put("S", "...");
+        this.codeMap.put("T", "-");
+        this.codeMap.put("U", "..-");
+        this.codeMap.put("V", "...-");
+        this.codeMap.put("W", ".--");
+        this.codeMap.put("X", "-..-");
+        this.codeMap.put("Y", "-.--");
+        this.codeMap.put("Z", "--..");
+        this.codeMap.put(" ", "-...-");
+        this.codeMap.put("1", ".----");
+        this.codeMap.put("2", "..---");
+        this.codeMap.put("3", "...--");
+        this.codeMap.put("4", "....-");
+        this.codeMap.put("5", ".....");
+        this.codeMap.put("6", "-....");
+        this.codeMap.put("7", "--...");
+        this.codeMap.put("8", "---..");
+        this.codeMap.put("9", "----.");
+        this.codeMap.put("0", "-----");
+    }
+
+    /**
+     * Diese Funktion ueberprueft ob der uebergebene Buchstabe in der codeMap enthalten ist.
+     * Wenn er enthalten ist, wird der zugehoerige Morsecode zurueck gegeben, ansonsten null.
+     *
+     * @param buchstabe : char : Zu uebersetzender Buchstabe.
+     * @return String : Der zugehoerige Morsecode aus der codeMap.
+     */
+    private String getMorsecode(char buchstabe) {
+        return this.codeMap.getOrDefault(String.valueOf(buchstabe).toUpperCase(), null);
+    }
+
+    /**
+     * Der uebergebene String wird in seine einzelnen Zeichen (char) zerlegt und an die Funktion getMorsecode
+     * uebergeben und der zugehoerige Morsecode rausgesucht.
+     * Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe-String zusammengesetzt.
+     * Wenn kein zugehoeriger Code in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
+     * Enigma nicht vorhanden war.
+     *
+     * @param input : String : Zu konvertierender Text.
+     * @return String : Der in Morsecode konvertierte Text.
+     */
+    public String convertBuchstabeToMorsecode(String input) {
+        StringBuilder sb = new StringBuilder();
+        String morsecode;
+
+        // Durch alle char im uebergebenen String loopen
+        for (int i = 0; i < input.length(); i++) {
+            morsecode = this.getMorsecode(input.charAt(i));
+            if (morsecode != null) {
+                sb.append(morsecode).append(' ');
+            }
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Diese Funktion ueberprueft ob der uebergebene Morsecode in der codeMap enthalten ist.
+     * Wenn er enthalten ist, wird der zugehoerige Buchstabe zurueckgegeben, ansonsten null.
+     *
+     * @param morsecode : String : Der zu uebersetzende Morsecode.
+     * @return : String : Der zugehoerige Buchstabe aus der codeMap.
+     */
+    private String getBuchstabe(String morsecode) {
+        String result = null;
+
+        // Loopt duch die codeMap und erstellt daraus ein Set
+        for (Entry<String, String> entry : this.codeMap.entrySet()) {
+            if (entry.getValue().equals(morsecode)) {
+                result = entry.getKey();
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Der uebergebene String wird in ein String-Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
+     * Anschließend wird das Array durchlaufen und die Elemente an die Funktion getBuchstabe uebergeben um den
+     * zugehoerigen Buchstaben zu erhalten.
+     * Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe String zusammengesetzt.
+     * Wenn kein zugehoeriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert, da es bei der
+     * Enigma nicht vorhanden war.
+     *
+     * @param input : String : Zu konvertierender Morsecode.
+     * @return String : Der in Text konvertierte Morsecode.
+     */
+    public String convertMorsecodeToBuchstabe(String input) {
+        StringBuilder sb = new StringBuilder();
+        String buchstabe;
+
+        String[] morsecodes = input.split(" ");
+
+        // Durch alle char im uebergebenen String loopen
+        for (String morsecode : morsecodes) {
+            buchstabe = this.getBuchstabe(morsecode);
+            if (buchstabe != null) {
+                sb.append(buchstabe);
+            }
+        }
+
+        return sb.toString();
+    }
+}

src/main/java/projekt/enigma/model/Reflektor.java

+package projekt.enigma.model;
+
+/**
+ * Klasse Reflektor
+ * <br>
+ * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und codiert diesen.
+ * Der codierte Buchstabe wird an die Klasse Walze wieder zurueckgegeben.
+ * <br>
+ * Prinzipiell verhaelt sich die Klasse Reflektor wie die Klasse Walze, ausser das sie sich
+ * nach Betaetigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
+ * an andere Walzen zum Drehen.
+ */
+public class Reflektor {
+
+    /**
+     * Funktion codiere
+     * <br>
+     * Durchsucht den String alphabet nach der Position des mitgegebenen Buchstabens und
+     * gibt den Character an der entsprechenden Position im String reflektor zurueck.
+     *
+     * @param buchstabe : Character : der zu codierende Buchstabe.
+     * @return char : Der codierte Buchstabe aus dem Reflektor.
+     */
+    public char codiere(Character buchstabe) {
+        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String reflektor = "EJMZALYXVBWFCRQUONTSPIKHGD";
+
+        return reflektor.charAt(alphabet.indexOf(buchstabe));
+    }
+}

src/main/java/projekt/enigma/model/Steckbrett.java

+package projekt.enigma.model;
+
+/**
+ * <p>
+ * Klasse Steckbrett
+ * <br>
+ * Das Steckbrett diente dazu, Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
+ * Die Klasse Steckbrett nimmt bis zu 10 paarweise zu vertauschende Buchstabenpaare entgegen, prueft diese auf
+ * Zulaessigkeit und tauscht diese dann paarweise aus.
+ */
+public class Steckbrett {
+
+    /**
+     * orginalBuchstaben: String : der jeweils den ersten zu vertauschenden Buchstaben enthaelt.
+     */
+    private String originalBuchstaben;
+
+    /**
+     * getauschteBuchstaben: String : der jeweils den zweiten zu vertauschenden Buchstaben enthaelt.
+     */
+    private String getauschteBuchstaben;
+
+    /**
+     * Konstruktor Steckbrett
+     * <br>
+     * Erzeugt zwei Strings und initialisiert diese.
+     */
+    public Steckbrett() {
+        originalBuchstaben = "";
+        getauschteBuchstaben = "";
+    }
+
+    /**
+     * Funktion setzeVertauschung
+     * <br>
+     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) uebergeben.
+     * Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
+     * <br>
+     * Anschliessend wird:
+     * <p>
+     * buchstabe1 dem String orginalBuchstaben angehaengt.
+     * buchstabe2 dem String getauschteBuchstaben angehaengt.
+     * </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 zulaessig 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 uebergeben.
+     * Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
+     * <br>
+     * Anschliessend wird:
+     * <p>
+     * buchstabe1 in den String orginalBuchstaben auf die Position (steckbrettPort) geschrieben.
+     * buchstabe2 in den String getauschteBuchstaben auf die Position (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 zulaessig ist, true, ansonsten false.
+     */
+    public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
+        char[] original;
+        char[] getauscht;
+
+        new Fehler().debug("setzeVertauschung(int " + steckbrettPort + ", char |" + buchstabe1 + "|, char |" + buchstabe2 + "|)", false);
+
+        if ((!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) ||
+                (buchstabe1 == ' ' && buchstabe2 == ' ')) {
+
+            new Fehler().debug("-> Original:\t" + originalBuchstaben, false);
+            new Fehler().debug("-> Getauscht:\t" + getauschteBuchstaben, false);
+            original = originalBuchstaben.toCharArray();
+            getauscht = getauschteBuchstaben.toCharArray();
+
+            original[steckbrettPort] = buchstabe1;
+            getauscht[steckbrettPort] = buchstabe2;
+
+            originalBuchstaben = String.valueOf(original);
+            getauschteBuchstaben = String.valueOf(getauscht);
+            new Fehler().debug("<- Original:\t" + originalBuchstaben, false);
+            new Fehler().debug("<- Getauscht:\t" + getauschteBuchstaben, false);
+
+            new Fehler().debug("true\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
+            return true;
+        } else {
+            new Fehler().debug("false\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
+            return false;
+        }
+    }
+
+    /**
+     * Funktion ueberpruefeVertauschungen
+     * <br>
+     * Die Funktion ueberpruefeVertauschungen prueft, ob der uebergebene Buchstabe bereits in den beiden Strings
+     * orginalBuchstaben und getauschteBuchstaben vorhanden ist.
+     * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
+     * (ein Buchstabe nicht mehrmals vertauscht wird).
+     *
+     * @param buchstabe : Character: zu pruefender Buchstabe.
+     * @return result : boolean : Wenn false, dann darf der Buchstabe genutzt werden. Wenn er schon vorhanden ist,
+     * wird true zurueckgegeben.
+     */
+    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;
+        }
+    }
+
+    /**
+     * Tauscht die Buchstaben im Alphabet aus und gibt ein modifiziertes Alphabet zurueck.
+     *
+     * @param port : int : Platz der getauschten Buchstaben.
+     * @return alphabet : String : Alphabet mit getauschtem Buchstabenpaar.
+     */
+    public String fetchVerfuegbareBuchstaben(int port) {
+        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+        for (char c : this.originalBuchstaben.toCharArray()) {
+            alphabet = alphabet.replace(String.valueOf(c), "");
+        }
+
+        for (char c : this.getauschteBuchstaben.toCharArray()) {
+            alphabet = alphabet.replace(String.valueOf(c), "");
+        }
+
+        alphabet += originalBuchstaben.charAt(port);
+        alphabet += getauschteBuchstaben.charAt(port);
+
+        return alphabet;
+    }
+}
\ No newline at end of file

src/main/java/projekt/enigma/model/Walze.java

+package projekt.enigma.model;
+
+/**
+ * Klasse Walze
+ * <br>
+ * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
+ * <br>
+ * 1. Walzennummer (Die Walze enthaelt die 26 Buchstaben des Alphabets und codiert diese.
+ * Fuenf verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabets
+ * vertauschen).
+ * <br>
+ * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
+ * den Drehzeitpunkt der linken Nachbarwalze).
+ */
+public class Walze {
+
+	//region Variablen
+	/**
+	 * Die Anzahl der getaetigten Walzendrehungen.
+	 */
+	private int turns;
+
+	/**
+	 * Das String-Array aller bekannter aktueller Walzen.
+	 */
+	private String[] walzen;
+
+	/**
+	 * alphabet : String : enthaelt die Buchstaben des Alphabets.
+	 */
+	private String alphabet;
+
+	/**
+	 * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt.
+	 */
+	private char ringstellung;
+
+	/**
+	 * walzenNr : int : Bestimmt, welche Walze genutzt wird.
+	 */
+	private int walzenNr;
+
+	//endregion
+
+	//region Konstruktor
+	/**
+	 * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt.
+	 *
+	 * @param walzenNr     : int : Nummer der gewaehlten Walze.
+	 * @param ringstellung : int : Einstellung des Umsprungpunktes.
+	 */
+	public Walze(int walzenNr, int ringstellung) {
+		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);
+	}
+
+	//endregion
+
+	//region Funktionen & Methoden
+	/**
+	 * Dreht die Walze: Zaehlt die Umdrehungen (turns) um eins hoch oder runter, je nach Drehrichtung.
+	 * <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 zurueck.
+	 * @return checkRing : boolean : gibt true zurueck, wenn der Umspringpunkt erreicht wurde.
+	 */
+	boolean dreheWalze(int richtung) {
+		boolean checkRing = false;
+		int korrekturFaktor = 0;
+
+		if ((richtung == -1) || (richtung == 1)) {
+			if (richtung == 1) {
+				this.turns++;
+			} else {
+				korrekturFaktor = 1;
+				this.turns--;
+			}
+
+			// gleicht die Ringstellung mit der aktuellen Position ab
+			if ((this.alphabet.indexOf(this.getPosition()) + korrekturFaktor) % 26
+					== this.alphabet.indexOf(this.ringstellung)) {
+				checkRing = true;
+			}
+		}
+
+		return checkRing;
+	}
+
+	/**
+	 * Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
+	 *
+	 * @param buchstabe : char : Buchstabe, der verschluesselt werden soll.
+	 * @return char : verschluesselter Buchstabe.
+	 */
+	public char codiere(char buchstabe) {
+		return this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26);
+	}
+
+	/**
+	 * Decodiert den mitgegebenen Buchstaben anhand des Alphabets.
+	 *
+	 * @param buchstabe : char : Buchstabe, der decodiert werden soll.
+	 * @return char : decodierter Buchstabe.
+	 */
+	char codiere2(char buchstabe) {
+		return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) - this.turns + 520) % 26);
+	}
+
+	/**
+	 * @return String : Gibt den Verschluesselungs-String der ausgewaehlten Walze zurueck.
+	 */
+	private String fetchWalze() {
+		return walzen[walzenNr];
+	}
+
+	//endregion
+
+	//region Setter
+	/**
+	 * Setzt die Walzennummer. Es stehen fuenf Walzen zur Auswahl.
+	 *
+	 * @param walzenNr : int : Walzennummer.
+	 */
+	private void setWalzenNr(int walzenNr) {
+		if ((walzenNr > 0) && (walzenNr < 6)) {
+			this.walzenNr = walzenNr - 1;
+		} else {
+			System.err.println("Keine gültige Walzennummer");
+		}
+	}
+
+	/**
+	 * Setzt die Initiale Ringstellung der Walze.
+	 * Es sind nur Zahlen von 1 - 26 zugelassen.
+	 * <br>
+	 * Die Ringstellung wird zum char umgewandelt.
+	 * Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
+	 *
+	 * @param ringstellung : int : Punkt an dem die Nachbarwalze umspringt.
+	 */
+	void setRingstellung(int ringstellung) {
+		if ((ringstellung > 0) && (ringstellung <= 26)) {
+			this.ringstellung = this.alphabet.charAt(ringstellung - 1);
+		} else {
+			this.ringstellung = 'Z';
+		}
+	}
+
+	/**
+	 * Stellt die Grundeinstellung der Walze ein.
+	 * Ermittelt, wie oft die Walze gedreht werden muss, bis die Grundeinstellung erreicht ist.
+	 *
+	 * @param buchstabe : Character : Einstellung der Walze.
+	 */
+	void setPosition(Character buchstabe) {
+		this.turns = alphabet.indexOf(buchstabe);
+	}
+	//endregion
+
+	//region Getter
+	/**
+	 * Gibt den Buchstaben zurueck, der aktuell in der Walze eingestellt ist.
+	 *
+	 * @return char : Ermittelte Stelle im Alphabet, anhand der aktuellen Anzahl der Drehungen.
+	 */
+	Character getPosition() {
+		return this.alphabet.charAt(turns % 26);
+	}
+
+	/**
+	 * Getter der Walzennummer.
+	 * @return walzenNr : int : gibt Walzennummer zurueck.
+	 */
+	int getWalzenNr() {
+		return this.walzenNr;
+	}
+	//endregion
+}
\ No newline at end of file

src/main/java/projekt/enigma/view/ChkBoxGridPane.java

+package projekt.enigma.view;
+
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.CheckBox;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.layout.GridPane;
+import projekt.enigma.model.Codierer;
+
+import java.util.Arrays;
+
+/**
+ * Die Klasse ChkBoxGripPane erweitert das GridPane Objekt.
+ * Wir erstellen ein GridPane in welches Checkboxen gelegt werden.
+ * Die Anzahl der Checkboxen wird durch die verfuegbarenBuchstaben festgelegt.
+ * Für jeden Buchstaben in diesem char Array, wird eine Checkbox erstellt und auf das Gridpane gelegt.
+ */
+public class ChkBoxGridPane extends GridPane {
+
+    // Der globale Checkbox Array
+    private CheckBox[] checkbox;
+    // Die Buchstaben die für das jeweilige Pane selectiert werden sollen
+    private String checkedBuchstaben;
+    // Die Anzahl der möglichen Checkboxen
+    private int charSize;
+    // Das Codierer Objekt. Dieses wird benötigt um auf die Funktionen für das Steckbrett zuzugreifen
+    private Codierer codierer;
+    // Der Steckbrett Port für welchen das Pane und die Checkboxen erstellt werden sollen
+    private int port;
+    // Die verfügbaren Buchstaben für den jeweiligen Port
+    private char[] verfuegbareBuchstaben;
+    // Das Button Objekt des Ports über den dieses Pane gesteuert wird
+    private ToggleButton tBtnPort;
+
+    /**
+     * Hier werfen wir die Checkboxen auf das Gridpane und weißen ihnen die Propertys zu.
+     * Außerdem wird hier auch der Listener generiert womit wir prüfen ob die maximale Auswahlmöglichkeit
+     * erreicht ist.
+     * Es können maximal zwei Checkboxen ausgewählt werden. Wenn zwei erreicht sind, werden die restlichen Checkboxen
+     * deaktiviert. Wenn nur noch eine oder keine Box ausgewählt ist, werden die restlichen wieder aktiviert.
+     * Bei null und zwei Boxen, werden die Buchstaben in das Steckbrett geschrieben.
+     * Andere Auswahlmöglchkeiten stehen nicht zur Verfügung, da ein Kabel nur zwei Enden hat in der Regel.
+     *
+     * @param codierer : Codierer Objekt
+     * @param port     : int
+     * @param tBtnPort : ToogleButton
+     */
+    public ChkBoxGridPane(Codierer codierer, int port, ToggleButton tBtnPort) {
+        this.codierer = codierer;
+        this.port = port;
+        this.tBtnPort = tBtnPort;
+        this.verfuegbareBuchstaben = this.codierer.fetchVerfuegbareBuchstaben(this.port).toCharArray();
+        Arrays.sort(this.verfuegbareBuchstaben);
+        charSize = this.verfuegbareBuchstaben.length;
+        this.checkedBuchstaben = tBtnPort.getText();
+        initializeComponents();
+    }
+
+    /**
+     * Es wird ein GridPane erzeugt, das zwei Spalten und abhängig von der Länge des
+     * Arrays (Character[] alphabet) Reihen hat. Das Label der CheckBoxen soll
+     * abhängig von deren Index links bzw. recht erzeugt werden
+     */
+    private void initializeComponents() {
+        checkbox = new CheckBox[charSize];
+
+        this.setAlignment(Pos.CENTER);
+
+        // Für jeden verfügbaren Buchstaben einen Durchlauf
+        for (int i = 0; i < this.verfuegbareBuchstaben.length; i++) {
+            if (this.verfuegbareBuchstaben[i] != 20 && this.verfuegbareBuchstaben[i] != ' ') {
+                checkbox[i] = new CheckBox(this.verfuegbareBuchstaben[i] + "");
+                checkbox[i].setPadding(new Insets(1, 1, 1, 1));
+
+                if (!checkedBuchstaben.equals("")) {
+                    if (!checkedBuchstaben.contains(String.valueOf(this.verfuegbareBuchstaben[i]))) {
+                        checkbox[i].setDisable(true);
+                    } else {
+                        checkbox[i].setSelected(true);
+                    }
+                } else {
+                    checkbox[i].setSelected(false);
+                    checkbox[i].setDisable(false);
+                }
+
+                // Der Listener für die jeweilige Checkbox
+                checkbox[i].selectedProperty().addListener((observable, oldValue, newValue) -> {
+                    String portSelection = "";
+                    int zaehler = 0;
+
+                    // Die selektierten Chechkboxen zählen
+                    for (CheckBox cb : checkbox) {
+                        if (cb != null && cb.isSelected()) {
+                            zaehler++;
+                        }
+                    }
+                    // Wenn nur eine oder keine Checkbox ausgewählt ist
+                    if (zaehler == 1 || zaehler == 0) {
+                        for (CheckBox cb : checkbox) {
+                            if (cb != null && cb.isDisabled()) {
+                                cb.setDisable(false);
+                            }
+                        }
+                    }
+                    // Es ist keine Checkbox ausgewählt
+                    if (zaehler == 0) {
+                        // Daten ins Steckbrett schreiben
+                        this.codierer.setzeSteckbrett(this.port, "");
+                        // Und den Button neu beschreiben
+                        tBtnPort.setText(portSelection);
+                    }
+                    // Das Maximum an selektierten Checkboxen (2) ist erreicht
+                    if (zaehler == 2) {
+                        for (CheckBox cb : checkbox) {
+                            if (cb != null && !cb.isSelected()) {
+                                cb.setDisable(true);
+                            } else {
+                                if (cb != null) {
+                                    portSelection += cb.getText();
+                                }
+                            }
+                        }
+                        // Daten ins Steckbrett schreiben
+                        this.codierer.setzeSteckbrett(this.port, "");
+                        this.codierer.setzeSteckbrett(this.port, portSelection);
+                        // Und den Button neu beschreiben
+                        tBtnPort.setText(portSelection);
+                    }
+                });
+
+                // Eine neue Row im Gridpane anlegen für den nächsten Button
+                this.addRow(i + 1);
+                this.add(checkbox[i], 2, i + 1, 1, 1);
+            }
+        }
+        // Das Pane anzeigen
+        this.setVisible(true);
+    }
+
+    /**
+     * Gibt den Anzahl der zur Verfügung stehenden Buchstaben zurück.
+     * Anhang dieses Wertes, wird die Anzahl der Checkboxen festgelegt.
+     *
+     * @return int : Anzahl der möglcihen chars
+     */
+    public int getCharSize() {
+        return charSize;
+    }
+}
+

src/main/resources/enigma/kenngruppe.fxml

-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.scene.control.Button?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.TextField?>
-<?import javafx.scene.layout.AnchorPane?>
-
-
-<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="257.0" prefWidth="300.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="enigma.KenngruppeController">
-   <children>
-      <Label layoutX="81.0" layoutY="29.0" text="Bitte Kenngruppe eingeben!" AnchorPane.leftAnchor="70.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="30.0" />
-      <Button fx:id="secondaryButton" layoutX="72.0" layoutY="178.0" onAction="#switchToPrimary" text="Kenngruppe bestätigen!" AnchorPane.leftAnchor="70.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="170.0" />
-      <TextField layoutX="81.0" layoutY="84.0" AnchorPane.leftAnchor="70.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="100.0" />
-   </children>
-</AnchorPane>

src/test/java/enigma/model/ReflektorTest.java → src/test/java/projekt/enigma/model/ReflektorTest.java

-package enigma.model;
+package projekt.enigma.model;
 
 import org.junit.Assert;
 import org.junit.Test;

src/test/java/enigma/model/SteckbrettTest.java → src/test/java/projekt/enigma/model/SteckbrettTest.java

-package enigma.model;
+package projekt.enigma.model;
 
 import org.junit.Assert;
 import org.junit.Test;