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