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/10] 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/10] 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/10] 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/10] 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/10] 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/10] 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/10] =?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/10] 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/10] 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/10] 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