diff --git a/src/main/java/projekt/enigma/model/Codierer.java b/src/main/java/projekt/enigma/model/Codierer.java
index b1389e0526563e5f67e626f10798f5b4b7e0b450..17b1fc5436d9364440c3fb1867f7e363e05e72ad 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 51bf3a8b377e37edaa1e303a21409f0dea83c87f..e43959ff3db9498099139438511f3cf0f1244786 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));
+ }
+ }
+ }
}