Klasse Walze

src/main/java/Enigma/model/Codebuch.java

@@ -5,7 +5,7 @@ package Enigma.model;
  * Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
  * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
  * mussten um die Texte zu ver/entschlüsseln.
- * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walzen gesetzt und deren Grundeinstellung
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
  * vorgenommen.
  * Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
  * festgelegt war.

src/main/java/Enigma/model/Walze.java

+package Enigma.model;
+
+public class Walze {
+
+    Character buchstabe = null;
+    Character ringstellung = null;
+    int walzennr = 0;
+    int iPositionBuchstabe = 0;
+    int iPositionBuchstabeRe = 0;
+    Character[] walze = new Character[25];
+
+    /**
+     * Gibt die Parameter der Walze mit
+     *
+     * @param walzennr : int : Nummer der gewaehlten Walze
+     * @param buchstabe : Character : Grundeinstellung der Walze
+     * @param ringstellung : Character : Einstellung des Notch
+     */
+    public Walze(int walzennr, Character buchstabe, Character ringstellung) {
+        this.walzennr = walzennr;
+        this.buchstabe = buchstabe;
+        this.ringstellung = ringstellung;
+    }
+
+    /**
+     * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
+     */
+    public char getBuchstabe() {
+        return buchstabe;
+    }
+
+    /**
+     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+     * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
+     *
+     * @param buchstabe : Character : Grundeinstellung der Walze
+     */
+    private void setBuchstabe(Character buchstabe) {
+        this.buchstabe.toUpperCase(buchstabe);
+
+        if(buchstabe.isLetter(buchstabe)) {
+            this.buchstabe = buchstabe;
+        } else {
+            this.buchstabe = 'A';
+        }
+
+    }
+
+    /**
+     * @return ringstellung : Character : gibt die neue Ringstellung zurueck
+     */
+    public char getRingstellung() {
+        return ringstellung;
+    }
+
+
+    /**
+     * Gibt die Initiale Ringstellung der Walze an.
+     * Es sind nur Zahlen von 1 - 26 zugelassen.
+     * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
+     *
+     * @param ringstellung : Character : Punkt an dem die Walze umspringt
+     */
+    private void setRingstellung(Character ringstellung) {
+
+        if(buchstabe.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
+            this.ringstellung = ringstellung;
+        } else {
+            this.ringstellung = '1';
+        }
+    }
+
+    /**
+     * @return walzennr : int : gibt die Walzennummer zurueck
+     */
+    public int getWalzennr() {
+        return walzennr;
+    }
+
+    /**
+     * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
+     *
+     * @param walzennr : int : setzt die Walzennummer
+     */
+    private void setWalzennr(int walzennr) {
+        if(walzennr > 0 && walzennr < 6) {
+            this.walzennr = walzennr;
+        } else {
+            System.err.println("Keine gültige Walzennummer");
+        }
+    }
+
+    /**
+     * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
+     *
+     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+     */
+    private Character[] walzenNummer() {
+
+        //Walze nach der Cheffrierung
+        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 (getWalzennr()) {
+            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;
+    }
+
+    /**
+     * Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
+     * der Cheffrierung auf der gewaehlten Walze abgleichen zu koennen.
+     *
+     * @return iPositionBuchstabe : int : Position des Buchstaben im Array
+     */
+    public int positionBuchstabe() {
+
+        //Alphabetswalze
+        Character[] walzeAlpha = {'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'};
+
+        int index = 0;
+
+        //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+        for(index = 0; index < walzeAlpha.length; index++) {
+            if(buchstabe.equals(walzeAlpha[index])) {
+                iPositionBuchstabe = index;
+                break;
+            }
+        }
+
+        return iPositionBuchstabe;
+    }
+
+
+    /**
+     * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
+     * anhand der gewaehlten Walze.
+     *
+     * @param iPositionBuchstabe : int : Position des zu cheffrierenden Buchstabens
+     * @param walze : Character[] : ausgewaehlte Walze
+     * @return cheffrierterBuchstabe : Character : cheffrierter Buchstabe
+     */
+    public Character codierterBuchstabe(int iPositionBuchstabe, Character[] walze) {
+        Character codierterBuchstabe = walze[iPositionBuchstabe];
+        return codierterBuchstabe;
+    }
+
+
+    /**
+     * Nimmt die Startposition, die aus der Walzeneinstellung geholt wird und
+     * erhoeht sie um eins.
+     * Die Variable wird ueberschrieben und zaehlt von nun an die Position mit.
+     * Ab Position 25 wird wieder bei 0 angefangen.
+     *
+     * @param iPositionBuchstabe : int : alte Position der Walze
+     * @return iPositionBuchstabe : int : neue Position der Walze
+     */
+    public int vorstellenDerWalze(int iPositionBuchstabe) {
+
+        if(iPositionBuchstabe == 25) {
+            iPositionBuchstabe = 0;
+        } else {
+            iPositionBuchstabe += 1;
+        }
+
+        return iPositionBuchstabe;
+    }
+
+    /**
+     * Ermittelt die Position des Buchstaben auf der gewaehlten Walze, um die Position mit
+     * der Cheffrierung auf der AlphaWalze abgleichen zu koennen.
+     *
+     * @param walzennr : int : gibt die gewaehlte Walze zurueck
+     * @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
+     */
+    public int positionBuchstabeReverse(int walzennr) {
+
+        int index = 0;
+
+        //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+        for(index = 0; index < walze.length; index++) {
+            if(buchstabe.equals(walze[index])) {
+                iPositionBuchstabeRe = index;
+                break;
+            }
+        }
+        return iPositionBuchstabeRe;
+    }
+
+    /**
+     * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+     * anhand der AlphaWalze.
+     *
+     * @param iPositionBuchstabeRe : int : Position des zu cheffrierenden Buchstabens
+     * @return codierterBuchstabeRe : Character : cheffrierter Buchstabe
+     */
+    public Character codierterBuchstabeReverse(int iPositionBuchstabeRe) {
+        //Alphawalze
+        Character[] walzeAlpha = {'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'};
+
+        Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
+        return codierterBuchstabeRe;
+    }
+
+}