diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index a9cdd0d88a066b473ec56f66313bb51bd2456464..ea3af64831862d96dafb73e1aab21617d45b76bf 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,14 +1,11 @@ image: maven:latest +cache: + key: EnigmaCache + stages: - - clean - build - test - - deploy - -Clean Project files: - stage: clean - script: mvn clean Compile new version: stage: build @@ -21,10 +18,4 @@ Run JUnit tests and verify: reports: junit: - target/surefire-reports/TEST-*.xml - - target/failsafe-reports/TEST-*.xml - -Deploy new version as Release: - stage: deploy - script: - - mvn versions:set -DnewVersion=$CI_COMMIT_TAG - - mvn assembly:assembly + - target/failsafe-reports/TEST-*.xml \ No newline at end of file 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 724cb462b9b6034bd2544aed4bd3446ebb7b1d0d..bf1c2aa20132b34479d75b51830aa1bb4164d836 100644 --- a/src/main/java/projekt/enigma/model/Codierer.java +++ b/src/main/java/projekt/enigma/model/Codierer.java @@ -14,463 +14,504 @@ import java.util.Random; */ public class Codierer { - /** - * 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; - - /** - * Der Konstruktor des Codierers - * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert. - */ - public Codierer() { - - this.nachricht = ""; - this.spruchschluessel = ""; - this.spruchschluesselCodiert = ""; - this.kenngruppe = ""; - this.codebuch = new Codebuch(); - this.codebuch.fetchTagesschluessel(); - } - - /** - * 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 - * in die Hardware gebaut. - * <br> - * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und - * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben. - * <br> - * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen - * Codebuch Eintrag. - */ - private void initialisiereHardware() { - - // Das Steckbrett initialisieren - Steckbrett sb = new Steckbrett(); - char[][] verbinder = this.codebuch.getSteckverbindung(); - - // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen - for (char[] kabel : verbinder) { - sb.setzeVertauschung(kabel[0], kabel[1]); - } - - // Die Hardware aus dem Koffer holen (initialisieren) - this.hardware = new Hardware(); - - // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen - this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]); - this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]); - this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]); - - // Der Hardware das gesetzte Steckbrett zuweisen - this.hardware.setSteckbrett(sb); - - // Ein Reflektor Objekt erstellen und der Hardware bekannt geben - this.hardware.setReflektor(new Reflektor()); - - } - - /** - * Hier wird ein neuer Spruchschlüssel generiert. - * <p> - * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem - * Tagesschlüssel codiert, hinzugefügt. - * <br> - * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert, - * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist. - * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt. - * <br> - * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat. - */ - public void generateSpruchschluessel() { - - String klartext = ""; - - while (klartext.length() < 3) { - String temp = this.randomBuchstabe(); - if (!klartext.contains(temp)) { - klartext += temp; - } - } - - this.spruchschluessel = klartext; - this.spruchschluesselCodiert = this.codiere(klartext + klartext, false); - - // Walzen auf den Spruchschlüssel stellen - this.hardware.setzePosition(0, this.spruchschluessel.charAt(0)); - this.hardware.setzePosition(1, this.spruchschluessel.charAt(1)); - this.hardware.setzePosition(2, this.spruchschluessel.charAt(2)); - - // Die Kenngruppe codieren und in der Nachricht speichern - 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 - * Tagescodes codierte, Spruchschlüssel. - */ - private String generateKopf() { - Calendar cal = Calendar.getInstance(); - - // 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) + " "; - } - - /** - * Einen zufälligen Buchstaben aus dem Alphabet generieren. - * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind. - * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben. - * - * @return String : ein zufällig generierter Buchstabe - */ - private String randomBuchstabe() { - return String.valueOf((char) ('A' + new Random().nextInt(26))); - } - - /** - * 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 = ""; - } - - /** - * 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() { - - 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; - } - - /** - * 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 String : Kenngruppe - */ - public String getKenngruppe() { - return kenngruppe; - } - - /** - * Setzt die Kenngruppe welche die Enigma gerade benutzt. - * - * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt - */ - public void setKenngruppe(String kenngruppe) { - - this.kenngruppe = kenngruppe; - this.initialisiereHardware(); - - } - - /** - * Gibt die bisher erstellte Nachricht zurück - * - * @return String : Erstellte Nachricht - */ - public String getNachricht() { - return nachricht; - } - - /** - * Gibt die aktuellen Buchstaben auf den Walzen zurück - * - * @return char[] : Walzen Array mit der aktuellen Position - */ - public char[] getWalzen() { - char[] walzen = new char[3]; - walzen[0] = this.hardware.getWalzen()[0].getPosition(); - walzen[1] = this.hardware.getWalzen()[1].getPosition(); - walzen[2] = this.hardware.getWalzen()[2].getPosition(); - - return walzen; - } - - /** - * Hier wird ein einzelner Buchstabe verschlüsselt. - * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht. - * In der Regel ist dies der Fall. - * - * @param buchstabe : char : Der zu codierende Buchstabe - * @param save : boolean : Nachricht speichern oder nicht - * @return char : Der codierte Buchstabe - */ - public char codiere(char buchstabe, boolean save) { - char codiert = this.hardware.codiere(buchstabe); - if (save) { - this.nachricht += codiert; - } - - return codiert; - } - - /** - * Codiert den Übergebenen String. - * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht. - * In der Regel ist dies der Fall. - * - * @param klartext : String : Der zu codierende Text - * @param save : boolean : Nachricht speichern oder nicht - * @return String : Der codierte Text zusätzlich als Rückgabe - */ - public String codiere(String klartext, boolean save) { - - StringBuilder sb = new StringBuilder(); - - for (char buchstabe : klartext.toCharArray()) { - sb.append(this.codiere(buchstabe, save)); - } - - return sb.toString(); - } - - /** - * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht. - * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum. - * In der Regel ist dies der Tag des Nachrichten empfangs. - * - * @param codierteNachricht : String : Enigma codierte Nachricht - * @param tag : int : Tag der Nachricht - * @return String : decodierte Nachricht - */ - private String decodiere(String codierteNachricht, int tag) { - - // Hardware reseten und Tageseinstellungen aus dem Codebuch laden - this.initialisiereHardware(); - this.codebuch.fetchTagesschluessel(tag); - - String[] nachricht = codierteNachricht.split(" "); - StringBuilder sb = new StringBuilder(); - - // Uhrzeit - sb.append(nachricht[0]).append(" "); - - // Zeichen Anzahl der Nachricht - sb.append(nachricht[1]).append(" "); - - // Spruchschlüssel - String spruchschluessel = this.decodiereString(nachricht[2]); - sb.append(spruchschluessel).append(" "); - sb.append(this.decodiereString(nachricht[3])).append(" "); - - // Walzen neu einstellen mit dem Spruchschlüssel - this.hardware.setzePosition(0, spruchschluessel.charAt(0)); - this.hardware.setzePosition(1, spruchschluessel.charAt(1)); - this.hardware.setzePosition(2, spruchschluessel.charAt(2)); - - // Nachricht decodieren - sb.append(this.decodiereString(nachricht[4])); - - return sb.toString(); - } - - /** - * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen. - * Der String wird dann decodiert zurück gegeben. - * - * @param nachricht : String : Der zu decodierende Text - * @return String : Der decodierte Text - */ - private String decodiereString(String nachricht) { - - StringBuilder sb = new StringBuilder(); - - for (char buchstabe : nachricht.toCharArray()) { - if (buchstabe > 0) { - sb.append(this.hardware.codiere(buchstabe)); - } - } - - return sb.toString(); - } - - /** - * 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)); - } - - /** - * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist. - * <p> - * setSteckbrett ausführen mit beiden Buchstaben als String - * - * @param buchstabe : char : Der zuletzt eingegebene Buchstabe - * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false - */ - public boolean pruefeSteckbrettPort(char buchstabe) { - return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe); - } - - /** - * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück. - * - * @param empfangeneNachricht : String : Die empfangene Nachricht als String - * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde. - */ - public String empfangenerSpruchschluessel(String empfangeneNachricht) { - String[] nachricht = empfangeneNachricht.split(" "); - - return nachricht[2]; - } - - /** - * 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 Walzennummer aus dem Codebuch zurück - * - * @return int[] : Array mit den Nummern der drei eingesetzten Walzen - */ - public int[] getchWalzenNr() { - return this.codebuch.getWalzenlage(); - } - - /** - * Gibt die Steckverbindungen aus dem Codebuch zurück - * - * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett - */ - 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() { - this.hardware.dreheWalzen(-1); - } + //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; + //endregion + + //region Konstruktor + /** + * Der Konstruktor des Codierers + * Hier werden die globalen Variablen auf ihre Standart Werte gesetzt sowie die Objekte Initialisiert. + */ + public Codierer() { + + this.nachricht = ""; + this.spruchschluessel = ""; + this.spruchschluesselCodiert = ""; + this.kenngruppe = ""; + 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 + * in die Hardware gebaut. + * <br> + * Ein Reflektor wird definiert, jedoch keine Werte zugewisen, da wir nur einen besitzen und + * deshalb alle Einstellungen hierfür Statisch im Reflektor definiert haben. + * <br> + * Das Steck wird ebenfalls definiert und die notwendigen Kabel eingesteckt laut dem heutigen + * Codebuch Eintrag. + */ + private void initialisiereHardware() { + + // Das Steckbrett initialisieren + Steckbrett sb = new Steckbrett(); + char[][] verbinder = this.codebuch.getSteckverbindung(); + + // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen + for (char[] kabel : verbinder) { + sb.setzeVertauschung(kabel[0], kabel[1]); + } + + // Die Hardware aus dem Koffer holen (initialisieren) + this.hardware = new Hardware(); + + // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen + this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]); + this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]); + this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]); + + // Der Hardware das gesetzte Steckbrett zuweisen + this.hardware.setSteckbrett(sb); + + // 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> + * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem + * Tagesschlüssel codiert, hinzugefügt. + * <br> + * Hierfür wird mittels der Funktion "randomBuchstabe" ein zufälliger Buchstabe generiert, + * und geschaut ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist. + * Wenn nicht, wird der Buchstabe dem Spruchschlüssel hinzugefügt. + * <br> + * Dies wir nun so lange gemacht bis der Spruchschlüssel eine länge von drei Zeichen hat. + */ + public void generateSpruchschluessel() { + + String klartext = ""; + + while (klartext.length() < 3) { + String temp = this.randomBuchstabe(); + if (!klartext.contains(temp)) { + klartext += temp; + } + } + + this.spruchschluessel = klartext; + this.spruchschluesselCodiert = this.codiere(klartext + klartext, false); + + // Walzen auf den Spruchschlüssel stellen + this.hardware.setzePosition(0, this.spruchschluessel.charAt(0)); + this.hardware.setzePosition(1, this.spruchschluessel.charAt(1)); + this.hardware.setzePosition(2, this.spruchschluessel.charAt(2)); + + // Die Kenngruppe codieren und in der Nachricht speichern + this.codiere(this.kenngruppe, true); + } + + /** + * Erstellen des Nachrichten Kopfes. + * Hierfür wird die aktuelle Uhrzeit ausgelesen, die Länge der Nachricht sowie der, mit den + * Tagescodes codierte, Spruchschlüssel. + */ + private String generateKopf() { + Calendar cal = Calendar.getInstance(); + + // 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) + " "; + } + + /** + * Einen zufälligen Buchstaben aus dem Alphabet generieren. + * In der Funktion gibt es den String Alphabet, in welchem alle zulässigen Zeichen eingetragen sind. + * Aus diesem String wird nun zufällig ein Zeichen ausgewählt und zurück gegeben. + * + * @return String : ein zufällig generierter Buchstabe + */ + private String randomBuchstabe() { + return String.valueOf((char) ('A' + new Random().nextInt(26))); + } + //endregion + + //region setzte Funktionen + /** + * 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 setzeWalze(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 setzeRing(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 setzeWalzeNr(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 setzeSteckbrett(int port, String verbindung) { + return this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1)); + } + //endregion + + //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 Walzennummer aus dem Codebuch zurück + * + * @return int[] : Array mit den Nummern der drei eingesetzten Walzen + */ + 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(); + } + + /** + * Gibt die aktuellen Buchstaben auf den Walzen zurück + * + * @return char[] : Walzen Array mit der aktuellen Position + */ + public char[] fetchWalzen() { + char[] walzen = new char[3]; + walzen[0] = this.hardware.getWalzen()[0].getPosition(); + walzen[1] = this.hardware.getWalzen()[1].getPosition(); + walzen[2] = this.hardware.getWalzen()[2].getPosition(); + + 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. + * In der Regel ist dies der Fall. + * + * @param buchstabe : char : Der zu codierende Buchstabe + * @param save : boolean : Nachricht speichern oder nicht + * @return char : Der codierte Buchstabe + */ + public char codiere(char buchstabe, boolean save) { + + char codiert = this.hardware.codiere(buchstabe); + + if (save) { + this.nachricht += codiert; + } + + return codiert; + } + + /** + * Codiert den Übergebenen String. + * Man muss hier ebenfalls mitgeben ob der codierte String in Codierer.nachricht gespeichert werden soll oder nicht. + * In der Regel ist dies der Fall. + * + * @param klartext : String : Der zu codierende Text + * @param save : boolean : Nachricht speichern oder nicht + * @return String : Der codierte Text zusätzlich als Rückgabe + */ + public String codiere(String klartext, boolean save) { + + StringBuilder sb = new StringBuilder(); + + for (char buchstabe : klartext.toCharArray()) { + sb.append(this.codiere(buchstabe, save)); + } + + return sb.toString(); + } + + /** + * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma Nachricht. + * Ihr muss auch der Tag der codierung mitgegeben werden. Dieser weiß dein Funker im Funkraum. + * In der Regel ist dies der Tag des Nachrichten empfangs. + * + * @param codierteNachricht : String : Enigma codierte Nachricht + * @param tag : int : Tag der Nachricht + * @return String : decodierte Nachricht + */ + private String decodiere(String codierteNachricht, int tag) { + + // Hardware reseten und Tageseinstellungen aus dem Codebuch laden + this.initialisiereHardware(); + this.codebuch.fetchTagesschluessel(tag); + + // Nachricht splitten mit whitespace als delimiter + String[] nachricht = codierteNachricht.split(" "); + StringBuilder sb = new StringBuilder(); + + // Uhrzeit + sb.append(nachricht[0]).append(" "); + + // Zeichen Anzahl der Nachricht + sb.append(nachricht[1]).append(" "); + + // Spruchschlüssel + String spruchschluessel = this.decodiereString(nachricht[2]); + + sb.append(spruchschluessel).append(" "); + sb.append(this.decodiereString(nachricht[3])).append(" "); + + // Walzen neu einstellen mit dem Spruchschlüssel + this.hardware.setzePosition(0, spruchschluessel.charAt(0)); + this.hardware.setzePosition(1, spruchschluessel.charAt(1)); + this.hardware.setzePosition(2, spruchschluessel.charAt(2)); + + // Nachricht decodieren + sb.append(this.decodiereString(nachricht[4])); + + return sb.toString(); + } + + /** + * Zerlegt den übergebenen String in einen char Array und decodiert jedes Zeichen. + * Der String wird dann decodiert zurück gegeben. + * + * @param nachricht : String : Der zu decodierende Text + * @return String : Der decodierte Text + */ + private String decodiereString(String nachricht) { + + StringBuilder sb = new StringBuilder(); + + for (char buchstabe : nachricht.toCharArray()) { + if (buchstabe > 0) { + sb.append(this.hardware.codiere(buchstabe)); + } + } + + return sb.toString(); + } + //endregion + + //region Sonstige + + /** + * Prüft ob der Port auf den das Kabel gesteckt werden soll, noch frei ist. + * <p> + * setSteckbrett ausführen mit beiden Buchstaben als String + * + * @param buchstabe : char : Der zuletzt eingegebene Buchstabe + * @return boolean : Wenn der Buchstabe nicht vorhanden ist, wird true zurückgegeben, ansonsten false + */ + public boolean pruefeSteckbrettPort(char buchstabe) { + return this.hardware.getSteckbrett().ueberpruefeVertauschungen(buchstabe); + } + + /** + * Ließt aus der empfangenen Nachricht den Spruchschlüssel aus und gibt ihn zurück. + * + * @param empfangeneNachricht : String : Die empfangene Nachricht als String + * @return String : Der Spruchschlüssel mit welcher die Nachricht codiert wurde. + */ + public String empfangenerSpruchschluessel(String empfangeneNachricht) { + String[] nachricht = empfangeneNachricht.split(" "); + + return nachricht[2]; + } + + /** + * 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. + * + * @param kenngruppe : String : Kenngruppe welche die Enigma gerade benutzt + */ + public void setKenngruppe(String kenngruppe) { + + this.kenngruppe = kenngruppe; + this.initialisiereHardware(); + + } + //endregion + + //region Getter + + /** + * Gibt die bisher erstellte Nachricht zurück + * + * @return String : Erstellte Nachricht + */ + public String getNachricht() { + return nachricht; + } + + /** + * 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 String : Kenngruppe + */ + public String getKenngruppe() { + return kenngruppe; + } + + /** + * 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; + } + //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 99d41248aa3aca3a3529674c1750a79c4ebe8a3a..62394acabc254ca541c3165e641de8d5b24fb5f6 100644 --- a/src/main/java/projekt/enigma/model/Walze.java +++ b/src/main/java/projekt/enigma/model/Walze.java @@ -1,9 +1,8 @@ package projekt.enigma.model; -import java.util.Arrays; -import java.util.Collections; - /** + * TODO: Dokumentation aktuallisieren + * <p> * Klasse Walze * <br> * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften: @@ -17,228 +16,174 @@ import java.util.Collections; */ public class Walze { - /** - * walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt - */ - private Character[] alphabet; - - /** - * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt - */ - private char ringstellung; - - /** - * walzennr : int : Bestimmt, welche Walze genutzt wird - */ - private int walzennr; - - /** - * 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; - } - - 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'; - } - } - - /** - * 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 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 richtung) { - boolean checkRing = false; - int korrektorFaktor = 0; - - if (richtung == 1) { - Collections.rotate(Arrays.asList(this.walzeAlpha), -1); - } else { - korrektorFaktor = 1; - Collections.rotate(Arrays.asList(this.walzeAlpha), 1); - } - - // gleicht die Ringstellung mit der aktuellen Position ab - if (this.getPosition() + korrektorFaktor == this.ringstellung) { - checkRing = true; - } - - return checkRing; - } - - /** - * 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) { - /* durchsucht die (verschobene) Alphabetswalze nach dem aktuellen Buchstaben und - uebertraegt den Index auf die gewaehlte Codierwalze*/ - buchstabe = walzenNummer()[fetchArrayIndex(buchstabe, walzeAlpha)]; - - return buchstabe; - } - - /** - * 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) { - /* durchsucht die gewaehlte Walze nach dem aktuellen Buchstaben und - uebertraegt den Index auf die (verschobene) Alphabetswalze*/ - buchstabe = walzeAlpha[fetchArrayIndex(buchstabe, walzenNummer())]; - - return buchstabe; - } - - /** - * 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; - } - } - - 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"); - } - } - - /** - * 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)); - } - } - } -} + //region Variablen + /** + * Das String Array aller bekannter aktuellen Walzen + */ + String[] walzen; + + /** + * alphabet : String dass die Buchstaben des Alphabets enthaelt + */ + private String alphabet; + + /** + * ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt + */ + private char ringstellung; + + /** + * walzennr : int : Bestimmt, welche Walze genutzt wird + */ + private int walzenNr; + + /** + * Die Anzahl der getätigten Walzen Drehungen + */ + private int turns; + //endregion + + //region Konstruktor + /** + * Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt + * + * @param walzenNr : int : Nummer der gewaehlten Walze + * @param ringstellung : int : Einstellung des Umsprungpunktes + */ + public Walze(int walzenNr, int ringstellung) { + + this.walzen = new String[5]; + this.walzen[0] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ"; + this.walzen[1] = "AJDKSIRUXBLHWTMCQGZNPYFVOE"; + this.walzen[2] = "BDFHJLCPRTXVZNYEIWGAKMUSQO"; + this.walzen[3] = "ESOVPZJAYQUIRHXLNFTGKDCMWB"; + this.walzen[4] = "VZBRGITYUPSDNHLXAWMJQOFECK"; + this.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + this.turns = 0; + + this.setWalzenNr(walzenNr); + this.setRingstellung(ringstellung); + } + //endregion + + //region Funktionen & Methoden + /** + * Dreht die Walze: Zählt die Umdrehungen (Turns) um eines hoch oder runter, je nach Drehrichtung. + * <p> + * Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde. + * + * @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurück + * @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde + * TODO: Doku + */ + public boolean dreheWalze(int richtung) { + + boolean checkRing = false; + + 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; + } + + /** + * 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 this.fetchWalze().charAt((this.alphabet.indexOf(buchstabe) + this.turns) % 26); + } + + /** + * Decodiert den mitgegebenen Buchstaben mit Hilfe der (verschobenen) Walze + * + * @param buchstabe : char : Buchstabe, der decodiert werden soll + * @return buchstabe : char : decodierter Buchstabe + */ + public char codiere2(char buchstabe) { + + 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); + } + + /** + * Holt den korrekten String zu der Walze + * + * @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); + } + + /** + * 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 - 1; + } else { + System.err.println("Keine gültige Walzennummer"); + } + } + + /** + * 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'; + } + } + //endregion + + //region Getter + /** + * Gibt den Character zurueck, der aktuell in der Walze eingestellt ist + * + * @return Character am Index 0 des (verschobenen) Alphabets zurueck + */ + 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);