Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • d.eisold/enigma
  • Janschubi1993/enigma
  • TsunamiKlaus/enigma
  • alfatrainingkurse/java/enigma
  • FloriN/enigma
  • PaoloPinkel/enigma
6 results
Show changes
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 2675 additions and 2690 deletions
src/main/java/projekt/enigma/Main.java
View file @ 6cfa05da
package projekt.enigma;
import projekt.enigma.threads.ThreadApp;
import projekt.enigma.threads.ThreadFunkraum;
import java.sql.SQLException;
/**
* Startpunkt des Programms. Startet die Klasse App und damit die GUI.
*/
public class Main {
public static void main(String[] args) throws SQLException {
/**
* Startet die App
*
* @param args : String[] : Standard-Kommandozeilen-Parameter.
*/
public static void main(String[] args) {
App.main(args);
}
}
src/main/java/projekt/enigma/database/DatenbankSqlite.java
View file @ 6cfa05da
......@@ -3,25 +3,24 @@ package projekt.enigma.database;
import java.sql.*;
/**
* Dies ist die SQLite Datenbank Klasse
* In der SQLite Datei im Resources Ordner liegt das Codebuch welches benötigt wird um die
* Nachrichten mit der Enigma zu ver/entschlüsseln.
* Dies ist die SQLite Datenbank Klasse.
* In der SQLite Datei im Resources Ordner liegt das Codebuch welches benoetigt wird um die
* Nachrichten mit der Enigma zu ver/entschluesseln.
* Die Datenbank ist statisch und deshalb konnte sie im Resources Ordner hinterlegt werden.
* Für jeden Tag des Monats (1-31) ist ein eigener Eintrag enthalten welcher über die Funktion
* Für jeden Tag des Monats (1-31) ist ein eigener Eintrag enthalten welcher ueber die Funktion
* getCodebuch abgerufen werden kann.
* Zurückgegeben wird ein Array welcher in der getCodebuch Funktion genauer dokumentiert ist.
* Zurueckgegeben wird ein Array welcher in der getCodebuch Funktion genauer dokumentiert ist.
*/
public class DatenbankSqlite {
/**
* Verbindung zur SQLite Datenbank aufbauen.
* Die Datei liegt in den Resources und ändert sich nicht,
* Die Datei liegt in den Resources und aendert sich nicht,
* weshalb der Pfad zu derselben fest hinterlegt ist.
*
* @return conn : Connection
* @return conn : Connection: statische Datenbankverbindung.
*/
private Connection connect() {
String url = "jdbc:sqlite::resource:projekt/enigma/codebuch.sqlite";
Connection conn = null;
......@@ -35,15 +34,15 @@ public class DatenbankSqlite {
}
/**
* Liest das Codebuch aus der SQLite Datenbank aus
* Dieser Funktion muss ein tag als int Wert übergeben werden.
* Anschließend wir eine Verbindung zur SQLite Datenbank aufgebaut und das Codebuch angefragt.
* Dieses wird in ein Object vom Type Codebuch gepackt und zurück gegeben.
* Liest das Codebuch aus der SQLite Datenbank aus.
* Dieser Funktion muss ein tag als int Wert uebergeben werden.
* Anschließend wird eine Verbindung zur SQLite Datenbank aufgebaut und das Codebuch angefragt.
* Dieses wird in ein Objekt vom Typ Codebuch gepackt und zurueckgegeben.
*
* Hole den heutigen Eintrag aus der SQLite Datenbank und erstelle daraus ein Codebuch Objekt
* Holt den heutigen Eintrag aus der SQLite Datenbank und erstellt daraus ein Codebuch Objekt.
*
* @param tag : int : Tag für welchen ein Codebuch benötigt wird.
* @return String : Die Einstellungen des angefragten Tages
* @param tag : int : Tag fuer welchen ein Codebuch benoetigt wird.
* @return String : Die Einstellungen des angefragten Tages.
* <p>
* String[0] : Tag
* String[1] : Walzenlage
......@@ -52,12 +51,11 @@ public class DatenbankSqlite {
* </p>
*/
public String[] getCodebuch(int tag) {
String[] codebuch = new String[4];
try {
Connection conn = this.connect();
PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag=? LIMIT 1");
PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag = ? LIMIT 1");
pstm.setInt(1, tag);
ResultSet rs = pstm.executeQuery();
......@@ -67,101 +65,8 @@ public class DatenbankSqlite {
codebuch[2] = rs.getString("Ringstellung");
codebuch[3] = rs.getString("Steckverbindung");
}
} catch (SQLException ignored) {
}
} catch (SQLException ignored) {}
return codebuch;
}
//region Random New Codebuch generieren
/**
* Setzt zufällige Codebuch Einträge in die SQLite Datenbank
* Tag => int
* Walzenlage => String w1,w2,w3
* Ringstellung => String r1,r2,r3
* Steckverbindungen => s0,s1,s2,s3,s4,s5,s6,s7,s8,s9
*/
/*
public void autoGenCodebuch() throws SQLException {
Connection conn = connect();
conn.setAutoCommit(false);
PreparedStatement pstmtInsert = conn.prepareStatement("INSERT INTO table_codebuch (Tag, Walzenlage, Ringstellung, Steckverbindung) VALUES (?, ?, ?, ?);");
for (int i = 3; i < 32; i++) {
pstmtInsert.setInt(1, i);
pstmtInsert.setString(2, walzenlage());
pstmtInsert.setString(3, ringstellung());
pstmtInsert.setString(4, steckverbindung());
pstmtInsert.executeUpdate();
}
conn.commit();
}
/**
* Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 5)
* die Zahlen sind durch Komma getrennt
* @return String => walzenlage mit drei Kommaseparierten Zufallszahlen zwischen 1 und 5
*/
/*
private static String walzenlage(){
String walzenlage;
Random random = new Random();
int[] w = new int[3];
for (int i = 0; i < 3; i++) {
w[i] = (random.nextInt(5))+1;
if (i==1&&w[0]==w[i])w[i]=(random.nextInt(5))+1;
if ((i==2&&w[0]==w[2])||(i==2&&w[1]==w[i]))w[i]=(random.nextInt(5))+1;
}
walzenlage= w[0]+","+w[1]+","+w[2];
return walzenlage;
}*/
/**
* Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 26)
* die Zahlen sind durch Komma getrennt
* @return String => ringstellung mit drei Kommaseparierten Zufallszahlen zwischen 1 und 26
*/
/*
private static String ringstellung(){
String ringstellung;
Random random = new Random();
int[] w = new int[3];
for (int i = 0; i < 3; i++) {
w[i] = (random.nextInt(26))+1;
}
ringstellung= w[0]+","+w[1]+","+w[2];
return ringstellung;
}*/
/**
* Generiert einen String aus 10 * 2 unterschiedlichen Großbuchstaben
* @return String => 10 Buchstabenkombinationen mit Komma getrennt
*//*
private static String steckverbindung(){
Random rnd = new Random();
String steckverbindung="";
char[] c = new char[20];
for (int i = 0; i < 20; i++) {
c[i] = (char) (rnd.nextInt(26) + 'A');
for (int j = i; j >= 0; j--) {
if (i>j) {
while (c[i]==c[j]) {
c[i] = (char) (rnd.nextInt(26) + 'A');
j= i-1;
}
}
}
}
steckverbindung = ((""+c[0]) + (""+c[1]) +"," +(""+c[2]) +(""+c[3]) + ","+(""+c[4]) +(""+c[5]) + ","+(""+c[6]) +(""+c[7]) + ","
+(""+c[8]) +(""+c[9]) + ","+(""+c[10]) +(""+c[11]) + ","+(""+c[12]) +(""+c[13]) + ","+(""+c[14]) +(""+c[15]) + ","+(""+c[16]) +(""+c[17]) + ","
+(""+c[18]) +(""+c[19]));
// System.out.println(steckverbindung);
// steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
return steckverbindung;
}*/
//endregion
}
src/main/java/projekt/enigma/model/Codebuch.java
View file @ 6cfa05da
......@@ -6,54 +6,54 @@ import java.time.LocalDate;
import java.time.ZoneId;
/**
* Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
* Jeder Enigma gehörte auch ein Codebuch bei, welches notwendig war um die Nachrichten zu ver/entschlüsseln.
* Das Codebuch war eines der essentiell wichtigen Sachen bei der Enigma.
* Jeder Enigma gehoerte auch ein Codebuch bei, welches notwendig war um die Nachrichten zu ver/entschluesseln.
* Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
* mussten um die Texte zu ver/entschlüsseln.
* Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
* mussten, um die Texte zu ver/entschluesseln.
* Hiernach wurden die Walzen eingesetzt, die Ringe für den Ruecksprung der Walze gesetzt und deren Grundeinstellung
* vorgenommen.
* Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
* Bei der Enigma I, um welche es hier geht, gab es zusaetzlich ein Steckbrett, welches ebenfalls im Codebuch
* festgelegt war.
* <p>
* Dieses Codebuch Objekt enthält die Einstellungen eines Tages, welche mittels Getter und Setter
* verarbeitet werden können.
* Dieses Codebuch enthaelt die Einstellungen eines Tages, welche mittels Getter und Setter
* verarbeitet werden koennen.
* <p>
* Zusätzlich gibt es zu Debug Zwecken eine überschriebene toString Funktion welche das Objekt als String zurück
* geben kann.
* Zusaetzlich gibt es zu Debug-Zwecken eine ueberschriebene toString Funktion, welche das Objekt als String
* zurueckgeben kann.
*/
public class Codebuch {
//region Variablen
/**
* TODO: Dokumentieren tag
* tag : int : gibt den Tag an
* tag : int : gibt den Tag eines Monats an.
*/
private int tag;
/**
* walzenlage : int[] : legt die Positionen der Walzen fest
* walzenlage : int[] : legt die Positionen der drei Walzen fest.
*/
private int[] walzenlage;
/**
* ringstellung : int[] : TODO ringstellung: char || int ?
* ringstellung : int[] : legt die Ringstellungen der drei Walzen fest.
*/
private int[] ringstellung;
/**
* steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar
* steckverbindung : char[][] : legt die Steckverbindungen im Steckbrett fest.
*/
private char[][] steckverbindung;
//endregion
//region Konstruktor
/**
* Im Konstruktor werden die Standardwerte gesetzt
* Im Konstruktor werden die Standardwerte gesetzt.
* <p>
* walzenlage : int[3] : Hier wird die Position der drei Walzen festgelegt.
* ringstellung : char[3] : Jede Walze hat einen Ring. Der Index steht für die Walze und der Value für
* die Position des Ringes.
* steckverbindung : char[10][] : Zehn Kabel können in das Steckbrett gesteckt werden. In diesem Array werden
* ringstellung : char[3] : Jede Walze hat einen Ring. Der Index steht fuer die Walze und der Value fuer
* die Position des Ringes.
* steckverbindung : char[10][] : Zehn Kabel koennen in das Steckbrett gesteckt werden. In diesem Array werden
* die Kabel mit ihren jeweiligen Buchsen hinterlegt.
*/
public Codebuch() {
......@@ -67,16 +67,16 @@ 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.
* Aus dem Tagesschluessel werden die Werte fuer die Walzenlage, Ringstellung und Steckverbindung
* gesetzt.
*
* @param tag : int[] : gibt einen Tag oder mehrere Tage mit
* @param tag : int[] : gibt keinen, einen Tag oder mehrere Tage mit.
*/
public void fetchTagesschluessel(int... tag) {
String[] walzenlage, ringstellung, db;
......@@ -89,6 +89,7 @@ public class Codebuch {
this.setTag(Integer.parseInt(db[0]));
// setzen der Walzenlage, Ringstellung, Steckverbindung
walzenlage = db[1].split(",");
for (int i = 0; i < 3; i++) {
this.setWalzenlage(i, Integer.parseInt(walzenlage[i]));
......@@ -100,14 +101,13 @@ public class Codebuch {
}
this.setSteckverbindung(db[3].split(","));
}
/**
* Gibt die aktuelle Instanz des Codebuches als String zurück.
* Hierbei werden der Tag die Walzenlagen, Ring-/Grundstellung sowie die Steckverbindungen zurück gegeben.
* Gibt die aktuelle Instanz des Codebuches als String zurueck.
* Hierbei werden der Tag die Walzenlagen, Ring-/Grundstellung sowie die Steckverbindungen zurueckgegeben.
*
* @return String : String des gesamten Objektes
* @return String : String des gesamten Objektes.
*/
@Override
public String toString() {
......@@ -148,16 +148,16 @@ public class Codebuch {
return sb.toString();
}
//endregion
//region Setter
/**
* Setzt die Steckverbindung dieser Instanz
* 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.
* Diese werden in zwei chars zerlegt und anschließend im globalen Array gespeichert.
*/
private void setSteckverbindung(String[] kabel) {
int counter = 0;
......@@ -171,67 +171,69 @@ public class Codebuch {
}
/**
* Setzt die Walzenlage dieser Instanz
* Setzt die Walzenlage dieser Instanz.
*
* @param position : int : Position der Walze
* @param walzenlage : int : Welche Walze wurde eingesetzt
* @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
* 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[]?
* @param ringstellung : int : An dieser Position soll die nächste Walze weiter gedreht werden.
*/
private void setRingstellung(int position, int ringstellung) {
this.ringstellung[position] = ringstellung;
}
/**
* Setzt den Tag dieser Instanz
* Setzt den Tag dieser Instanz.
*
* @param tag : int : Tag
* @param tag : int : Tag.
*/
void setTag(int tag) { this.tag = tag; }
void setTag(int tag) {
this.tag = tag;
}
//endregion
//region Getter
/**
* Gibt den Tag dieser Instanz zurück
* Gibt den Tag dieser Instanz zurueck.
*
* @return int : Tag
* @return int : Tag.
*/
public int getTag() {
return tag;
}
/**
* Gibt die Walzenlage dieser Instanz zurück
* Gibt die Walzenlage dieser Instanz zurueck.
*
* @return String[] : Walzenlage TODO: String[] || int[]?
* @return walzenlage : int[] : Walzenlage.
*/
public int[] getWalzenlage() {
return walzenlage;
}
/**
* Gibt die Ringstellung dieser Instanz zurück
* Gibt die Ringstellung dieser Instanz zurueck.
*
* @return String[] : Ringstellung TODO: String[] || int[]?
* @return ringstellung : int : Ringstellung.
*/
public int[] getRingstellung() {
return ringstellung;
}
/**
* Gibt die Steckverbindung dieser Instanz zurück
* Gibt die Steckverbindungen dieser Instanz zurueck.
*
* @return String[] : Steckverbindung
* @return steckerverbindung : char[][] : Steckverbindung.
*/
// TODO
public char[][] getSteckverbindung() {
return this.steckverbindung;
}
......
src/main/java/projekt/enigma/model/Fehler.java
View file @ 6cfa05da
......@@ -5,74 +5,91 @@ import javafx.scene.control.Alert.AlertType;
import projekt.enigma.App;
/**
* In dieser Klasse werden Fehler behandelt und an den User/Admin/Entwickler ausgegeben
* In dieser Klasse werden Fehler behandelt und an den User/Admin/Entwickler ausgegeben.
*/
public class Fehler {
/**
* Konstanten die anzeigen ob es sich um eine Funktion oder um eine Nachricht handelt.
*/
private static final String FUNCTION_PREFIX = "- ";
private static final String MESSAGE_PREFIX = "--> ";
private String functionPrefix = "- ";
private String messagePrefix = "--> ";
/**
* Zeige Fehler Dialog
*
* @param type : String : Art der Meldung (warning/information/error)
* @param subject : String : Titel des Dialoges
* @param message : String : Nachricht der Meldung
*/
public void showErrorDialog(String type, String subject, String message) {
Alert alert;
/**
* Zeige Fehler Dialog
*
* @param type : String : Art der Meldung (warning/information/error)
* @param subject : Titel des Dialoges
* @param message : Nachricht der Meldung
*/
public void showErrorDialog(String type, String subject, String message) {
new Fehler().debug(this.getClass().getName() + "."
+ new Throwable().getStackTrace()[0].getMethodName(), true);
new Fehler().debug(this.getClass().getName() + "." + new Throwable().getStackTrace()[0].getMethodName(), true);
/* Der Titel darf auch als leerer String uebergeben werden, dann wird ein Default gesetzt */
if (subject.equals("")) {
subject = "Es ist ein Fehler aufgetreten";
}
Alert alert;
/* Welcher Fehler Typ wurde uebergeben? */
switch (type) {
case "warning":
alert = new Alert(AlertType.WARNING);
break;
/* Der Titel darf auch als leerer String übergeben werden, dann wird ein Default gesetzt */
if (subject.equals("")) {
subject = "Es ist ein Fehler aufgetreten";
}
case "info":
alert = new Alert(AlertType.INFORMATION);
break;
/* Welcher Fehler Typ wurde übergeben? */
switch (type) {
case "warning":
alert = new Alert(AlertType.WARNING);
break;
case "info":
alert = new Alert(AlertType.INFORMATION);
break;
case "error":
alert = new Alert(AlertType.ERROR);
break;
default:
alert = new Alert(AlertType.NONE);
}
/* Setzt den Titel des Dialoges */
alert.setTitle(subject);
/* Setzt den Headertext des Dialoges */
alert.setHeaderText(null);
/* Setzt die Nachricht des Dialoges */
alert.setContentText(message);
/* Zeige den Dialog an */
alert.showAndWait();
}
case "error":
alert = new Alert(AlertType.ERROR);
break;
public void debug(String message, boolean isFunction) {
default:
alert = new Alert(AlertType.NONE);
}
if (App.getDebug() != 0) {
if (isFunction) {
System.out.println(functionPrefix + message);
} else {
System.out.println(messagePrefix + message);
}
}
}
//Anzeige des Alerts definieren
alert.setTitle(subject);
alert.setHeaderText(null);
alert.setContentText(message);
alert.showAndWait();
}
public void debug(String message, boolean isFunction, int debugLevel) {
/**
* Unter zuhilfenahme dieser Funktion koennen Debug Meldungen auf der Konsole ausgegeben werden,
* wenn in der App.java der Getter getDebug einen int > 0 zurueck gibt.
* Ueber diesen Getter kann man steuern ob Meldungen in der Konsole angezeigt werden sollen oder nicht.
*
* @param message : String : Nachricht
* @param isFunction : boolean : Gibt an ob ein Funktionsname uebergeben wird oder eine Debug Meldung
*/
public void debug(String message, boolean isFunction) {
if (App.getDebug() != 0) {
if (isFunction) {
System.out.println(FUNCTION_PREFIX + message);
} else {
System.out.println(MESSAGE_PREFIX + message);
}
}
}
if (App.getDebug() != 0 && (App.getDebug() >= debugLevel || App.getDebug() == 3) ) {
if (isFunction) {
System.out.println(functionPrefix + message);
} else {
System.out.println(messagePrefix + message);
}
}
}
/**
* Unter Zuhilfenahme dieser Funktion koennen Debug Meldungen auf der Konsole ausgegeben werden,
* wenn in der App.java der Getter getDebug einen int > 0 zurueck gibt.
* Ueber diesen Getter kann man steuern ob Meldungen in der Konsole angezeigt werden sollen oder nicht.
*
* @param message : String : Nachricht
* @param isFunction : boolean : Gibt an ob ein Funktionsname uebergeben wird oder eine Debug Meldung.
*/
public void debug(String message, boolean isFunction, int debugLevel) {
if (App.getDebug() != 0 && (App.getDebug() >= debugLevel || App.getDebug() == 3)) {
if (isFunction) {
System.out.println(FUNCTION_PREFIX + message);
} else {
System.out.println(MESSAGE_PREFIX + message);
}
}
}
}
\ No newline at end of file
src/main/java/projekt/enigma/model/Funkraum.java
View file @ 6cfa05da
package projekt.enigma.model;
import org.apache.http.HttpEntity;
import org.apache.http.HttpException;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
......@@ -23,97 +22,98 @@ import java.util.List;
* Der Funkraum kann Funksprueche empfangen und senden.
* Hierfuer wird eine Verbindung zu einem externen Service aufgebaut.
* Dieser Servive erwartet die Nachrichten im JSON Format. Dazu wird ein k als Kenngruppe
* (Benutzername) uebergeben und falls eine Nachricht gesendet werden soll, zusätzlich ein m mit der Nachricht.
* (Benutzername) uebergeben und falls eine Nachricht gesendet werden soll, zusaetzlich ein m mit der Nachricht.
* Beides wird als String gesendet.
*/
public class Funkraum {
/**
* Zum Empfangen liefert der Server, anstatt der Kenngruppe (k), den Empfangstag (t) der Nachricht mit, damit man
* die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
* {'m': 'Hello world', 't': '26'}
*
* @param kenngruppe : String : Kenngruppe dieser Enigma
* @return funkspruch : String[] : String Array wobei Index 0 dem Empfangstag entspricht und Index 1
* der empfangenen Nachricht
*/
public String[] empfangeFunkspruch(String kenngruppe) {
String[] funkspruch = new String[2];
/**
* Zum Empfangen liefert der Server, anstatt der Kenngruppe (k), den Empfangstag (t) der Nachricht mit, damit man
* die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
* {'m': 'Hello world', 't': '26'}
*
* @param kenngruppe : String : Kenngruppe dieser Enigma
* @return funkspruch : String[] : String Array wobei Index 0 dem Empfangstag entspricht und Index 1
* der empfangenen Nachricht.
* @throws NullPointerException : Exception : Keine Nachricht vorhanden.
*/
public String[] empfangeFunkspruch(String kenngruppe) {
String[] funkspruch = new String[2];
HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
try {
// Anfrage Parameter und Encoding setzen
List<NameValuePair> params = new ArrayList<>(2);
params.add(new BasicNameValuePair("k", kenngruppe));
httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
try {
// Anfrage Parameter und Encoding setzen
List<NameValuePair> params = new ArrayList<>(2);
params.add(new BasicNameValuePair("k", kenngruppe));
httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
// POST Request ausführen und Rückgabe verarbeiten
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
// POST Request ausfuehren und Rueckgabe verarbeiten
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
if (entity != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
JSONObject result = new JSONObject(reader.readLine());
if (entity != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
JSONObject result = new JSONObject(reader.readLine());
if (!result.getString("m").isEmpty()) {
funkspruch[0] = result.getString("t");
funkspruch[1] = result.getString("m");
}
}
} catch (UnsupportedEncodingException e) {
new Fehler().showErrorDialog("error", "Encoding wird nicht unterstützt",
"Kommunikation mit dem Feind wird als Landesverrat bestraft");
} catch (IOException e) {
new Fehler().showErrorDialog("error", "HTTP Post war nicht erfolgreich",
"Bitte wenden Sie sich an ihren Vorgesetzten.");
} catch (NullPointerException e) {
new Fehler().showErrorDialog("info", "Keiner schreibt dir...",
"Es liegen keine neuen Nachrichten im Funkraum für Sie vor.");
}
if (!result.getString("m").isEmpty()) {
funkspruch[0] = result.getString("t");
funkspruch[1] = result.getString("m");
}
}
} catch (UnsupportedEncodingException e) {
new Fehler().showErrorDialog("error", "Encoding wird nicht unterstützt",
"Kommunikation mit dem Feind wird als Landesverrat bestraft");
} catch (IOException e) {
new Fehler().showErrorDialog("error", "HTTP Post war nicht erfolgreich",
"Bitte wenden Sie sich an ihren Vorgesetzten.");
} catch (NullPointerException e) {
new Fehler().showErrorDialog("info", "Keiner schreibt dir...",
"Es liegen keine neuen Nachrichten im Funkraum für Sie vor.");
}
return funkspruch;
}
return funkspruch;
}
/**
* Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
* Dieser nimmt die Daten entgegen und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
* irgendwann, auf Anfrage, wieder abgerufen werden koennen.
* <p>
* Darauf antwortet der Server mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
* {'result': 200}
* <p>
* Die 200 heißt hier, dass alles erfolgreich durchgefuehrt werden konnte. Steht hier etwas anderes, ist ein Fehler
* aufgetreten und die Anfrage war nicht erfolgreich.
* In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggf spaeter erneut versucht werden.
*
* @param funkspruch : String : Der zu sendende Funkspruch
* @param kenngruppe : String : Die Kenngruppe dieser Engima
* @throws IOException : Exception : Funkspruch konnte nicht gesendet werden
*/
public void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
/**
* Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
* Dieser nimmt die Daten entgegen und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
* irgendwann, auf Anfrage, wieder abgerufen werden koennen.
* <br>
* Darauf antwortet der Server mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
* {'result': 200}
* <br>
* Die 200 heisst hier, dass alles erfolgreich durchgefuehrt werden konnte. Steht hier etwas anderes, ist ein Fehler
* aufgetreten und die Anfrage war nicht erfolgreich.
* In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggf. spaeter erneut versucht werden.
*
* @param funkspruch : String : Der zu sendende Funkspruch
* @param kenngruppe : String : Die Kenngruppe dieser Engima
* @throws IOException : Exception : Funkspruch konnte nicht gesendet werden
*/
public void sendeFunkspruch(String funkspruch, String kenngruppe) throws IOException {
HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
// Anfrage Parameter und Encoding setzen
List<NameValuePair> params = new ArrayList<>(2);
params.add(new BasicNameValuePair("k", kenngruppe));
params.add(new BasicNameValuePair("m", funkspruch));
httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
// Anfrage Parameter und Encoding setzen
List<NameValuePair> params = new ArrayList<>(2);
params.add(new BasicNameValuePair("k", kenngruppe));
params.add(new BasicNameValuePair("m", funkspruch));
httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
// POST Request ausführen und Rückgabe verarbeiten
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
// POST Request ausfuehren und Rueckgabe verarbeiten
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
if (entity != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
JSONObject result = new JSONObject(reader.readLine());
if (result.getInt("result") != 200) {
new Fehler().showErrorDialog("error", "HTTP Exception",
"Der andere Funker mag deine Nachricht nicht. " +
"Rüge ihn wenn du ihn wieder siehst...");
}
}
}
if (entity != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
JSONObject result = new JSONObject(reader.readLine());
if (result.getInt("result") != 200) {
new Fehler().showErrorDialog("error", "HTTP Exception",
"Der andere Funker mag deine Nachricht nicht. "
+ "Rüge ihn wenn du ihn wieder siehst...");
}
}
}
}
src/main/java/projekt/enigma/model/Hardware.java
View file @ 6cfa05da
package projekt.enigma.model;
/**
* In dieser Klasse wird die Hardware zusammen gefasst.
* Alle Komponenter der Enigma laufen hier zusammen.
* In dieser Klasse wird die Hardware zusammengefasst.
* Alle Komponenten der Enigma laufen hier zusammen.
*
* <p>
* walzen : Walze[] : Ist ein Array der drei eingebauten Walzen Objekte
* steckbrett : Steckbrett : Das Steckbrett mit den Verbindungen aus dem Codebuch
* reflektor : Reflektor : Dies ist das Objekt der Reflektors
* nachricht : String : Die verschlüsselte Nachricht wird in diesem String zusammen gesetzt und gespeichert
* kenngruppe : String : Früher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
* nachricht : String : Die verschluesselte Nachricht wird in diesem String zusammengesetzt und gespeichert
* kenngruppe : String : Frueher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
* Wir missbrauchen die Kenngruppe für einen Benutzernamen
* </p>
*/
......@@ -17,197 +17,191 @@ public class Hardware {
//region Variablen
/**
* TODO: Dokumentieren
* walzen: Walze-Array: erzeugt ein privates Array mit der die Anzahl der Walzen festgelegt wird.
*/
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.
* steckbrett: Steckbrett: erzeugt ein privates Steckbrett-Objekt
*/
public Hardware() {
this.walzen = new Walze[3];
}
//endregion
//region Funktionen & Methoden
private Steckbrett steckbrett;
/**
* Setzt eine Walze ein
*
* @param walze : int : Setzt die Walze mit der angegebenen Nummer ein
* @param walzenNr : int : Die Nummer der einzusetzenden Walze
* reflektor: Reflektor: erzeugt ein privates Reflektor-Objekt.
*/
public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
this.walzen[walze] = new Walze(walzenNr, ringstellung);
}
private Reflektor reflektor;
//endregion
/**
* 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);
}
//region Konstruktor
/**
* 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);
}
/**
* 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
/**
* 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) {
//region Funktionen & Methoden
new Fehler().debug(this.getClass().getName() + "." +
/**
* Setzt eine Walze ein.
*
* @param walze : int : Setzt die Walze mit der angegebenen Nummer ein.
* @param walzenNr : int : Die Nummer der einzusetzenden Walze.
* @param ringstellung : int : Setzt den Ring der Walze auf die angegebene Nummer.
*/
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 werden soll.
*/
public void setzePosition(int walze, char buchstabe) {
this.walzen[walze].setPosition(buchstabe);
}
/**
* Verschluesselt den uebergebenen Buchstaben und fuegt ihn der Nachricht hinzu.
* Debug Ausgabe auf der Konsole wird zusaetzlich ausgegeben.
*
* @param buchstabe char : Der zu ver/entschluesselnde Buchstabe.
* @return char : Der ver/entschluesselte Buchstabe.
*/
public char codiere(char buchstabe) {
new Fehler().debug(this.getClass().getName() + "." +
new Throwable().getStackTrace()[0].getMethodName(), true);
buchstabe = Character.toUpperCase(buchstabe);
String debug = String.format("Positionen: W1:%s W2:%s W3:%s",
this.walzen[0].getPosition(),
this.walzen[1].getPosition(),
this.walzen[2].getPosition());
debug += "\nI\tS\t3\t2\t1\tR\t1\t2\t3\tS\n" + buchstabe;
buchstabe = Character.toUpperCase(buchstabe);
String debug = String.format("Positionen: W1:%s W2:%s W3:%s",
this.walzen[0].getPosition(),
this.walzen[1].getPosition(),
this.walzen[2].getPosition());
debug += "\nI\tS\t3\t2\t1\tR\t1\t2\t3\tS\n" + buchstabe;
this.dreheWalzen(1);
buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
debug += "\t" + buchstabe;
buchstabe = this.walzen[2].codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[1].codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[0].codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.reflektor.codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[0].codiere2(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[1].codiere2(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[2].codiere2(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.steckbrett.codiere(buchstabe);
debug += "\t" + buchstabe;
new Fehler().debug(debug, false);
//Codiere Vorgang wird fuer jede Walze bis zum Reflektor mit der codiere Funktion durchgefuehrt.
//Auf dem Rueckweg wird mit der codiere2 Funktion codiert.
buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
debug += "\t" + buchstabe;
buchstabe = this.walzen[2].codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[1].codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[0].codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.reflektor.codiere(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[0].codiere2(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[1].codiere2(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.walzen[2].codiere2(buchstabe);
debug += "\t" + buchstabe;
buchstabe = this.steckbrett.codiere(buchstabe);
debug += "\t" + buchstabe;
new Fehler().debug(debug, false);
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)) {
if (this.walzen[1].dreheWalze(1)) {
this.walzen[0].dreheWalze(1);
}
}
}
} else {
for (int i = 0; i > richtung; richtung++) {
if (this.walzen[2].dreheWalze(-1)) {
if (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
/**
* Nach jeder Codierung eines Buchstabens muessen die Walzen gedreht werden.
* Hier ueberpruefen wir, welche der Walzen gedreht werden muessen und stossen den Vorgang an.
*
* @param richtung : int : +1 fuer eine Vorwaertsdrehung und -1 fuer eine Rueckwaertsdrehung.
*/
public void dreheWalzen(int richtung) {
if (richtung > 0) {
for (int i = 0; i < richtung; i++) {
if (this.walzen[2].dreheWalze(1)) {
if (this.walzen[1].dreheWalze(1)) {
this.walzen[0].dreheWalze(1);
}
}
}
} else {
for (int i = 0; i > richtung; richtung++) {
if (this.walzen[2].dreheWalze(-1)) {
if (this.walzen[1].dreheWalze(-1)) {
this.walzen[0].dreheWalze(-1);
}
}
}
}
}
//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);
}
/**
* 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;
}
//endregion
/**
* 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 : Umsprungpunkt der Walze.
*/
public void setWalzen(int position, int walze, int ringstellung) {
this.walzen[position] = new Walze(walze, ringstellung);
}
/**
* Gibt das Objekt des Steckbretts zurueck.
*
* @return steckbrett : Steckbrett-Objekt: Das eingesetzte Steckbrett mit seinen Kabeln, wenn eingesteckt.
*/
public Steckbrett getSteckbrett() {
return steckbrett;
}
/**
* Setzt das uebergebene 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
/**
* 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;
}
/**
* Gibt die verbauten Walzen Objekte zurück
*
* @return Walze[] : Array mit den Walzen Objekten
*/
public Walze[] getWalzen() {
return this.walzen;
}
//endregion
/**
* Setzt den Reflektor ein.
* In der Enigma I, welche hier nachgebaut wird, gab es nur einen Reflektor.
* Spaetere Versionen hatten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafuer erstellt,
* welches ausgetauscht werden kann.
*
* @param reflektor : Reflektor : Das Objekt des Reflektors.
*/
public void setReflektor(Reflektor reflektor) {
this.reflektor = reflektor;
}
/**
* Gibt die verbauten Walzen Objekte zurück.
*
* @return walzen : Walze[] : Array mit den Walzen Objekten.
*/
public Walze[] getWalzen() {
return this.walzen;
}
//endregion
}
src/main/java/projekt/enigma/model/Morsecode.java
View file @ 6cfa05da
package projekt.enigma.model;
import java.util.*;
import java.util.Map.Entry;
import java.util.TreeMap;
/**
* Diese Klasse definiert die Zugehörigkeit zwischen den Buchstaben A-Z und dem zugehörigen Morsecode.
* Diese Klasse definiert die Zugehoerigkeit zwischen den Buchstaben A-Z und dem Morsecode.
* Die Funktionen sollen Texte von und zu Morsecode konvertieren.
*/
public class Morsecode {
// Anlegen der codeMap als TreeMap
private TreeMap<String, String> codeMap = new TreeMap<>();
/**
* Im Konstruktor werden alle verfügbaren Buchstaben (A-Z) und deren zugehörigen
* Morsecodes, der codeMap hinzugefügt.
*/
public Morsecode() {
this.codeMap.put("A", ".-");
this.codeMap.put("B", "-...");
this.codeMap.put("C", "-.-.");
this.codeMap.put("D", "-..");
this.codeMap.put("E", ".");
this.codeMap.put("F", "..-.");
this.codeMap.put("G", "--.");
this.codeMap.put("H", "....");
this.codeMap.put("I", "..");
this.codeMap.put("J", ".---");
this.codeMap.put("K", "-.-");
this.codeMap.put("L", ".-..");
this.codeMap.put("M", "--");
this.codeMap.put("N", "-.");
this.codeMap.put("O", "---");
this.codeMap.put("P", ".--.");
this.codeMap.put("Q", "--.-");
this.codeMap.put("R", ".-.");
this.codeMap.put("S", "...");
this.codeMap.put("T", "-");
this.codeMap.put("U", "..-");
this.codeMap.put("V", "...-");
this.codeMap.put("W", ".--");
this.codeMap.put("X", "-..-");
this.codeMap.put("Y", "-.--");
this.codeMap.put("Z", "--..");
this.codeMap.put(" ", "-...-");
this.codeMap.put("1", ".----");
this.codeMap.put("2", ".----");
this.codeMap.put("3", "...--");
this.codeMap.put("4", "....-");
this.codeMap.put("5", ".....");
this.codeMap.put("6", "-....");
this.codeMap.put("7", "--...");
this.codeMap.put("8", "---..");
this.codeMap.put("9", "----.");
this.codeMap.put("0", "-----");
}
/**
* Diese Funktion überprüft ob das übergebene Buchstabe in der codeMap enthalten ist.
* Wenn es enthalten ist, wird der zugehörige Morsecode zurück gegeben, ansonsten null
*
* @param buchstabe : char : Zu übersetzender Buchstabe
* @return : String : Das zugehöriger Morsecode aus der codeMap
*/
private String getMorsecode(char buchstabe) {
// Testen ob das Char in der codeMap enthalten ist. Wenn ja, raussuchen und zurück geben
return this.codeMap.getOrDefault(String.valueOf(buchstabe).toUpperCase(), null);
}
/**
* Der übergebene String wird in seine einzelnen Zeichen (char) zerlegt und an die Funktion getMorsecode
* übergeben und der zugehörige Morsecode raus gesucht.
* Mittels eines StringBuilders werden die Ergebnisse zu einem Rückgabe String zusammen gesetzt.
* Wenn kein zugehöriger Code in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
* Enigma nicht vorhanden war.
*
* @param input : String : Zu konventierender Text
* @return String : Die in Morsecode konvertierte Text
*/
public String convertBuchstabeToMorsecode(String input) {
StringBuilder sb = new StringBuilder();
String morsecode;
// Durch alle char im übergebenen String loopen
for(int i = 0; i < input.length(); i++) {
// Wenn der char in der codeMap enthalten ist, an den Rückgabe String anheften, ansonsten nichts ignorieren.
morsecode = this.getMorsecode(input.charAt(i));
if(morsecode != null) {
sb.append(morsecode).append(' ');
}
}
// Gibt den konvertierten String zurück
return sb.toString();
}
/**
* Diese Funktion überprüft ob der übergebene Morsecode in der codeMap enthalten ist.
* Wenn er enthalten ist, wird der zugehörige Buchstabe zurück gegeben, ansonsten null
*
* @param morsecode : String : Der zu übersetzende Morsecode
* @return : String : Das zugehöriger Buchstaben aus der this.codeMap
*/
private String getBuchstabe(String morsecode) {
// Initialisieren des Rückgabe Strings
String result = null;
// Loopt duch die Codemap und erstellt daraus ein Set
for(Entry<String, String> entry : this.codeMap.entrySet()) {
// Wenn Value dem Morsecode entspricht, haben wir unseren Buchstaben gefunden und setzen ihn als Result
if(entry.getValue().equals(morsecode)) {
result = entry.getKey();
}
}
return result;
}
/**
* Der übergebene String wird in einen String Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
* Anschließend wird der Array durchlaufen und die Elemente an die Funktion getBuchstabe übergeben um den
* zugehörigen Buchstaben zu erhalten.
* Mittels eines StringBuilders werden die Ergebnisse zu einem Rückgabe String zusammen gesetzt.
* Wenn kein zugehöriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
* Enigma nicht vorhanden war.
*
* @param input : String : Zu konventierender Morsecode
* @return String : Der in Text konvertierte Morsecode
*/
public String convertMorsecodeToBuchstabe(String input) {
StringBuilder sb = new StringBuilder();
String buchstabe;
String[] morsecodes = input.split(" ");
// Durch alle char im übergebenen String loopen
for(String morsecode : morsecodes) {
// Wenn der char in der codeMap enthalten ist, an den Rückgabe String anheften, ansonsten nichts ignorieren.
buchstabe = this.getBuchstabe(morsecode);
if(buchstabe != null) {
sb.append(buchstabe);
}
}
// Gibt den konvertierten String zurück
return sb.toString();
}
/**
* Anlegen der codeMap als TreeMap.
*/
private TreeMap<String, String> codeMap;
/**
* Im Konstruktor werden alle verfuegbaren Buchstaben (A-Z) und deren zugehoerigen
* Morsecodes, der codeMap hinzugefuegt.
*/
public Morsecode() {
codeMap = new TreeMap<>();
this.codeMap.put("A", ".-");
this.codeMap.put("B", "-...");
this.codeMap.put("C", "-.-.");
this.codeMap.put("D", "-..");
this.codeMap.put("E", ".");
this.codeMap.put("F", "..-.");
this.codeMap.put("G", "--.");
this.codeMap.put("H", "....");
this.codeMap.put("I", "..");
this.codeMap.put("J", ".---");
this.codeMap.put("K", "-.-");
this.codeMap.put("L", ".-..");
this.codeMap.put("M", "--");
this.codeMap.put("N", "-.");
this.codeMap.put("O", "---");
this.codeMap.put("P", ".--.");
this.codeMap.put("Q", "--.-");
this.codeMap.put("R", ".-.");
this.codeMap.put("S", "...");
this.codeMap.put("T", "-");
this.codeMap.put("U", "..-");
this.codeMap.put("V", "...-");
this.codeMap.put("W", ".--");
this.codeMap.put("X", "-..-");
this.codeMap.put("Y", "-.--");
this.codeMap.put("Z", "--..");
this.codeMap.put(" ", "-...-");
this.codeMap.put("1", ".----");
this.codeMap.put("2", "..---");
this.codeMap.put("3", "...--");
this.codeMap.put("4", "....-");
this.codeMap.put("5", ".....");
this.codeMap.put("6", "-....");
this.codeMap.put("7", "--...");
this.codeMap.put("8", "---..");
this.codeMap.put("9", "----.");
this.codeMap.put("0", "-----");
}
/**
* Diese Funktion ueberprueft ob der uebergebene Buchstabe in der codeMap enthalten ist.
* Wenn er enthalten ist, wird der zugehoerige Morsecode zurueck gegeben, ansonsten null.
*
* @param buchstabe : char : Zu uebersetzender Buchstabe.
* @return String : Der zugehoerige Morsecode aus der codeMap.
*/
private String getMorsecode(char buchstabe) {
return this.codeMap.getOrDefault(String.valueOf(buchstabe).toUpperCase(), null);
}
/**
* Der uebergebene String wird in seine einzelnen Zeichen (char) zerlegt und an die Funktion getMorsecode
* uebergeben und der zugehoerige Morsecode rausgesucht.
* Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe-String zusammengesetzt.
* Wenn kein zugehoeriger Code in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
* Enigma nicht vorhanden war.
*
* @param input : String : Zu konvertierender Text.
* @return String : Der in Morsecode konvertierte Text.
*/
public String convertBuchstabeToMorsecode(String input) {
StringBuilder sb = new StringBuilder();
String morsecode;
// Durch alle char im uebergebenen String loopen
for (int i = 0; i < input.length(); i++) {
morsecode = this.getMorsecode(input.charAt(i));
if (morsecode != null) {
sb.append(morsecode).append(' ');
}
}
return sb.toString();
}
/**
* Diese Funktion ueberprueft ob der uebergebene Morsecode in der codeMap enthalten ist.
* Wenn er enthalten ist, wird der zugehoerige Buchstabe zurueckgegeben, ansonsten null.
*
* @param morsecode : String : Der zu uebersetzende Morsecode.
* @return : String : Der zugehoerige Buchstabe aus der codeMap.
*/
private String getBuchstabe(String morsecode) {
String result = null;
// Loopt duch die codeMap und erstellt daraus ein Set
for (Entry<String, String> entry : this.codeMap.entrySet()) {
if (entry.getValue().equals(morsecode)) {
result = entry.getKey();
}
}
return result;
}
/**
* Der uebergebene String wird in ein String-Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
* Anschließend wird das Array durchlaufen und die Elemente an die Funktion getBuchstabe uebergeben um den
* zugehoerigen Buchstaben zu erhalten.
* Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe String zusammengesetzt.
* Wenn kein zugehoeriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert, da es bei der
* Enigma nicht vorhanden war.
*
* @param input : String : Zu konvertierender Morsecode.
* @return String : Der in Text konvertierte Morsecode.
*/
public String convertMorsecodeToBuchstabe(String input) {
StringBuilder sb = new StringBuilder();
String buchstabe;
String[] morsecodes = input.split(" ");
// Durch alle char im uebergebenen String loopen
for (String morsecode : morsecodes) {
buchstabe = this.getBuchstabe(morsecode);
if (buchstabe != null) {
sb.append(buchstabe);
}
}
return sb.toString();
}
}
src/main/java/projekt/enigma/model/Reflektor.java
View file @ 6cfa05da
package projekt.enigma.model;
/**
* TODO: Dokumentation aktuallisieren
* Klasse Reflektor
* <br>
* Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
* Der kodierte Buchstabe wird an die Klasse Walze wieder zurückgegeben.
* Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und codiert diesen.
* Der codierte Buchstabe wird an die Klasse Walze wieder zurueckgegeben.
* <br>
* Prinzipiell verhält sich die Klasse Reflektor wie die Klasse Walze, außer das sie sich
* nach Betätigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
* an andere Walzen zum drehen.
* Prinzipiell verhaelt sich die Klasse Reflektor wie die Klasse Walze, ausser das sie sich
* nach Betaetigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
* an andere Walzen zum Drehen.
*/
public class Reflektor {
/**
* Funktion codiere
* <br>
* Durchsucht das konstante Char-Array WALZE_ALPHABET nach der Position eines bestimmten
* Buchstabens und gibt den Character an der entsprechenden Position im konstanten
* Char-Array WALZE_REFLEKTOR zurück.
* Durchsucht den String alphabet nach der Position des mitgegebenen Buchstabens und
* gibt den Character an der entsprechenden Position im String reflektor zurueck.
*
* @return WALZE_REFLEKTOR[iPositionReflektor]: Character: Der kodierte Buchstabe aus dem Reflektor
* @param buchstabe : Character : der zu codierende Buchstabe.
* @return char : Der codierte Buchstabe aus dem Reflektor.
*/
public char codiere(Character buchstabe) {
// 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 reflektor.charAt(alphabet.indexOf(buchstabe));
......
src/main/java/projekt/enigma/model/Steckbrett.java
View file @ 6cfa05da
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.
* Das Steckbrett diente dazu, Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
* Die Klasse Steckbrett nimmt bis zu 10 paarweise zu vertauschende Buchstabenpaare entgegen, prueft diese auf
* Zulaessigkeit und tauscht diese dann paarweise aus.
*/
public class Steckbrett {
/**
* orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
* orginalBuchstaben: String : der jeweils den ersten zu vertauschenden Buchstaben enthaelt.
*/
private String originalBuchstaben;
/**
* getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
* getauschteBuchstaben: String : der jeweils den zweiten zu vertauschenden Buchstaben enthaelt.
*/
private String getauschteBuchstaben;
/**
* Konstruktor Steckbrett
* <br>
* Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
* Erzeugt zwei Strings und initialisiert diese.
*/
public Steckbrett() {
originalBuchstaben = "";
getauschteBuchstaben = "";
}
......@@ -36,25 +33,24 @@ public class Steckbrett {
/**
* 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.
* Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) uebergeben.
* Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
* <br>
* Anschließend wird:
* Anschliessend wird:
* <p>
* buchstabe1 in das Array orginalBuchstaben auf den nächsten, freien Index geschrieben
* buchstabe2 in das Array getauschteBuchstaben auf den nächsten, freien Index geschrieben.
* buchstabe1 dem String orginalBuchstaben angehaengt.
* buchstabe2 dem String getauschteBuchstaben angehaengt.
* </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
* @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 zulaessig ist, true, ansonsten false.
*/
public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2) && originalBuchstaben.length() <= 20) {
if ((!ueberpruefeVertauschungen(buchstabe1)) && (!ueberpruefeVertauschungen(buchstabe2))
&& (originalBuchstaben.length() <= 20)) {
originalBuchstaben += buchstabe1;
getauschteBuchstaben += buchstabe2;
return true;
} else {
return false;
......@@ -62,47 +58,64 @@ public class Steckbrett {
}
/**
* Funktion setzeVertauschung mit angabe eines Ports von 1 - 10
* 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.
* Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port uebergeben.
* Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
* <br>
* Anschließend wird:
* Anschliessend wird:
* <p>
* buchstabe1 in das Array orginalBuchstaben auf den Index (steckbrettPort) geschrieben
* buchstabe2 in das Array getauschteBuchstaben auf den Index (steckbrettPort) geschrieben.
* buchstabe1 in den String orginalBuchstaben auf die Position (steckbrettPort) geschrieben.
* buchstabe2 in den String getauschteBuchstaben auf die Position (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
* @return boolean : Wenn die Vertauschung zulaessig ist, true, ansonsten false.
*/
public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
char[] original;
char[] getauscht;
if (!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) {
originalBuchstaben.replace(originalBuchstaben.charAt(steckbrettPort), buchstabe1);
getauschteBuchstaben.replace(getauschteBuchstaben.charAt(steckbrettPort), buchstabe2);
new Fehler().debug("setzeVertauschung(int " + steckbrettPort + ", char |" + buchstabe1 + "|, char |" + buchstabe2 + "|)", false);
if ((!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) ||
(buchstabe1 == ' ' && buchstabe2 == ' ')) {
new Fehler().debug("-> Original:\t" + originalBuchstaben, false);
new Fehler().debug("-> Getauscht:\t" + getauschteBuchstaben, false);
original = originalBuchstaben.toCharArray();
getauscht = getauschteBuchstaben.toCharArray();
original[steckbrettPort] = buchstabe1;
getauscht[steckbrettPort] = buchstabe2;
originalBuchstaben = String.valueOf(original);
getauschteBuchstaben = String.valueOf(getauscht);
new Fehler().debug("<- Original:\t" + originalBuchstaben, false);
new Fehler().debug("<- Getauscht:\t" + getauschteBuchstaben, false);
new Fehler().debug("true\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
return true;
} else {
new Fehler().debug("false\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
return false;
}
}
/**
* Funktion ueberpruefeVertauschungen
* <br>
* Die Funktion ueberpruefeVertauschungen prueft ob der übergebene Buchstabe bereits in den beiden Arrays
* (orginalBuchstaben) und (getauschteBuchstaben) vorhanden ist.
* Die Funktion ueberpruefeVertauschungen prueft, ob der uebergebene Buchstabe bereits in den beiden Strings
* 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
* @param buchstabe : Character: zu pruefender Buchstabe.
* @return result : boolean : Wenn false, dann darf der Buchstabe genutzt werden. Wenn er schon vorhanden ist,
* wird true zurueckgegeben.
*/
public boolean ueberpruefeVertauschungen(Character buchstabe) {
boolean result = false;
if (originalBuchstaben.contains(String.valueOf(buchstabe)) ||
......@@ -122,14 +135,35 @@ public class Steckbrett {
* @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))) {
} else if (getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
return originalBuchstaben.charAt(getauschteBuchstaben.indexOf(buchstabe));
} else {
return buchstabe;
}
}
/**
* Tauscht die Buchstaben im Alphabet aus und gibt ein modifiziertes Alphabet zurueck.
*
* @param port : int : Platz der getauschten Buchstaben.
* @return alphabet : String : Alphabet mit getauschtem Buchstabenpaar.
*/
public String fetchVerfuegbareBuchstaben(int port) {
String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (char c : this.originalBuchstaben.toCharArray()) {
alphabet = alphabet.replace(String.valueOf(c), "");
}
for (char c : this.getauschteBuchstaben.toCharArray()) {
alphabet = alphabet.replace(String.valueOf(c), "");
}
alphabet += originalBuchstaben.charAt(port);
alphabet += getauschteBuchstaben.charAt(port);
return alphabet;
}
}
\ No newline at end of file
src/main/java/projekt/enigma/model/Walze.java
View file @ 6cfa05da
package projekt.enigma.model;
/**
* TODO: Dokumentation aktuallisieren
* <p>
* Klasse Walze
* <br>
* Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
* <br>
* 1. Walzennummer (Die Walze enthält die 26 Buchstaben des Alphabeths und codiert diese.
* 5 verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabeths
* paarweise vertauschen)
* 1. Walzennummer (Die Walze enthaelt die 26 Buchstaben des Alphabets und codiert diese.
* Fuenf verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabets
* vertauschen).
* <br>
* 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
* den Drehzeitpunkt der linken Nachbarwalze)
* den Drehzeitpunkt der linken Nachbarwalze).
*/
public class Walze {
//region Variablen
/**
* Die Anzahl der getätigten Walzen Drehungen
* TODO: Wieder auf private setzen
* Die Anzahl der getaetigten Walzendrehungen.
*/
public int turns;
private int turns;
/**
* Das String Array aller bekannter aktuellen Walzen
* Das String-Array aller bekannter aktueller Walzen.
*/
private String[] walzen;
/**
* alphabet : String dass die Buchstaben des Alphabets enthaelt
* alphabet : String : enthaelt die Buchstaben des Alphabets.
*/
private String alphabet;
/**
* ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
* ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt.
*/
private char ringstellung;
/**
* walzennr : int : Bestimmt, welche Walze genutzt wird
* walzenNr : int : Bestimmt, welche Walze genutzt wird.
*/
private int walzenNr;
//endregion
//region Konstruktor
/**
* Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt
* Ueberschriebener Konstruktor, der die Eingangsparameter der Walze mit gibt.
*
* @param walzenNr : int : Nummer der gewaehlten Walze
* @param ringstellung : int : Einstellung des Umsprungpunktes
* @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";
......@@ -61,33 +62,33 @@ public class Walze {
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.
* Dreht die Walze: Zaehlt die Umdrehungen (turns) um eins 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
* @param richtung : int : 1 dreht die Walze weiter und -1 dreht sie einen Schritt zurueck.
* @return checkRing : boolean : gibt true zurueck, wenn der Umspringpunkt erreicht wurde.
*/
public boolean dreheWalze(int richtung) {
boolean dreheWalze(int richtung) {
boolean checkRing = false;
int korrektorFaktor = 0;
int korrekturFaktor = 0;
if (richtung == -1 || richtung == 1) {
if ((richtung == -1) || (richtung == 1)) {
if (richtung == 1) {
this.turns++;
} else if (richtung == -1) {
korrektorFaktor = 1;
} else {
korrekturFaktor = 1;
this.turns--;
}
// gleicht die Ringstellung mit der aktuellen Position ab
if ((this.alphabet.indexOf(this.getPosition()) + korrektorFaktor) % 26 == this.alphabet.indexOf(this.ringstellung)) {
if ((this.alphabet.indexOf(this.getPosition()) + korrekturFaktor) % 26
== this.alphabet.indexOf(this.ringstellung)) {
checkRing = true;
}
}
......@@ -98,41 +99,39 @@ public class Walze {
/**
* Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
*
* @param buchstabe : char : Buchstabe, der verschluesselt werden soll
* @return buchstabe : char : verschluesselter Buchstabe
* @param buchstabe : char : Buchstabe, der verschluesselt werden soll.
* @return 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
* Decodiert den mitgegebenen Buchstaben anhand des Alphabets.
*
* @param buchstabe : char : Buchstabe, der decodiert werden soll
* @return buchstabe : char : decodierter Buchstabe
* @param buchstabe : char : Buchstabe, der decodiert werden soll.
* @return char : decodierter Buchstabe.
*/
public char codiere2(char buchstabe) {
return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) - this.turns + 260) % 26);
char codiere2(char buchstabe) {
return this.alphabet.charAt((this.fetchWalze().indexOf(buchstabe) - this.turns + 520) % 26);
}
/**
* Holt den korrekten String zu der Walze
*
* @return walze : Character[] : gibt die gewaehlte Walze zurueck
* @return String : Gibt den Verschluesselungs-String der ausgewaehlten Walze zurueck.
*/
private String fetchWalze() {
return walzen[walzenNr];
}
//endregion
//region Setter
/**
* Setzt die Walzennummer. Es stehen fuenf Walze zur Auswahl.
* Setzt die Walzennummer. Es stehen fuenf Walzen zur Auswahl.
*
* @param walzenNr : int : Walzennummer
* @param walzenNr : int : Walzennummer.
*/
public void setWalzenNr(int walzenNr) {
private void setWalzenNr(int walzenNr) {
if ((walzenNr > 0) && (walzenNr < 6)) {
this.walzenNr = walzenNr - 1;
} else {
......@@ -143,13 +142,13 @@ public class Walze {
/**
* Setzt die Initiale Ringstellung der Walze.
* Es sind nur Zahlen von 1 - 26 zugelassen.
* <p>
* <br>
* Die Ringstellung wird zum char umgewandelt.
* Im Fehlerfall wird die Ringstellung standardmaessig auf 'Z' gesetzt.
*
* @param ringstellung : int : Punkt an dem die Walze umspringt
* @param ringstellung : int : Punkt an dem die Nachbarwalze umspringt.
*/
public void setRingstellung(int ringstellung) {
void setRingstellung(int ringstellung) {
if ((ringstellung > 0) && (ringstellung <= 26)) {
this.ringstellung = this.alphabet.charAt(ringstellung - 1);
} else {
......@@ -158,26 +157,32 @@ public class Walze {
}
/**
* * 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.
* Stellt die Grundeinstellung der Walze ein.
* Ermittelt, wie oft die Walze gedreht werden muss, bis die Grundeinstellung erreicht ist.
*
* @param buchstabe : Character : Einstellung der Walze
* @param buchstabe : Character : Einstellung der Walze.
*/
public void setPosition(Character buchstabe) {
void setPosition(Character buchstabe) {
this.turns = alphabet.indexOf(buchstabe);
}
//endregion
//region Getter
/**
* Gibt den Character zurueck, der aktuell in der Walze eingestellt ist
* Gibt den Buchstaben zurueck, der aktuell in der Walze eingestellt ist.
*
* @return Character am Index 0 des (verschobenen) Alphabets zurueck
* @return char : Ermittelte Stelle im Alphabet, anhand der aktuellen Anzahl der Drehungen.
*/
public Character getPosition() {
Character getPosition() {
return this.alphabet.charAt(turns % 26);
}
/**
* Getter der Walzennummer.
* @return walzenNr : int : gibt Walzennummer zurueck.
*/
int getWalzenNr() {
return this.walzenNr;
}
//endregion
}
\ No newline at end of file
src/main/java/projekt/enigma/threads/ThreadApp.java deleted 100644 → 0
View file @ b86f504c
package projekt.enigma.threads;
import projekt.enigma.App;
/**
* Thread fuer die Benutzeroberflaeche, wird durch das Interface Runnable erweitert
*/
public class ThreadApp implements Runnable {
private String[] args;
/**
* Ueberschriebene Funktion - fuehrt die Klasse App aus
*/
@Override
public void run() {
System.out.println("ThreadApp " + Thread.currentThread());
App app = new App();
app.main(args);
}
}
src/main/java/projekt/enigma/threads/ThreadFunkraum.java deleted 100644 → 0
View file @ b86f504c
package projekt.enigma.threads;
import projekt.enigma.model.Codierer;
import projekt.enigma.model.Funkraum;
/**
* Thread fuer den Funkraum, wird durch das Interface Runnable erweitert
*/
public class ThreadFunkraum implements Runnable {
String kenngruppe;
public ThreadFunkraum(String kenngruppe) {
this.kenngruppe = kenngruppe;
}
/**
* Ueberschriebene Funktion - fuehrt die Klasse Funkraum aus und startet
*/
@Override
public void run() {
Funkraum funkraum = new Funkraum();
System.out.println("Threadfunkraum" + Thread.currentThread());
funkraum.empfangeFunkspruch(this.kenngruppe);
}
}
src/main/java/projekt/enigma/view/ChkBoxGridPane.java 0 → 100644
View file @ 6cfa05da
package projekt.enigma.view;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.control.CheckBox;
import javafx.scene.control.ToggleButton;
import javafx.scene.layout.GridPane;
import projekt.enigma.model.Codierer;
import java.util.Arrays;
/**
* Die Klasse ChkBoxGripPane erweitert das GridPane Objekt.
* Wir erstellen ein GridPane in welches Checkboxen gelegt werden.
* Die Anzahl der Checkboxen wird durch die verfuegbarenBuchstaben festgelegt.
* Für jeden Buchstaben in diesem char Array, wird eine Checkbox erstellt und auf das Gridpane gelegt.
*/
public class ChkBoxGridPane extends GridPane {
// Der globale Checkbox Array
private CheckBox[] checkbox;
// Die Buchstaben die für das jeweilige Pane selectiert werden sollen
private String checkedBuchstaben;
// Die Anzahl der möglichen Checkboxen
private int charSize;
// Das Codierer Objekt. Dieses wird benötigt um auf die Funktionen für das Steckbrett zuzugreifen
private Codierer codierer;
// Der Steckbrett Port für welchen das Pane und die Checkboxen erstellt werden sollen
private int port;
// Die verfügbaren Buchstaben für den jeweiligen Port
private char[] verfuegbareBuchstaben;
// Das Button Objekt des Ports über den dieses Pane gesteuert wird
private ToggleButton tBtnPort;
/**
* Hier werfen wir die Checkboxen auf das Gridpane und weißen ihnen die Propertys zu.
* Außerdem wird hier auch der Listener generiert womit wir prüfen ob die maximale Auswahlmöglichkeit
* erreicht ist.
* Es können maximal zwei Checkboxen ausgewählt werden. Wenn zwei erreicht sind, werden die restlichen Checkboxen
* deaktiviert. Wenn nur noch eine oder keine Box ausgewählt ist, werden die restlichen wieder aktiviert.
* Bei null und zwei Boxen, werden die Buchstaben in das Steckbrett geschrieben.
* Andere Auswahlmöglchkeiten stehen nicht zur Verfügung, da ein Kabel nur zwei Enden hat in der Regel.
*
* @param codierer : Codierer Objekt
* @param port : int
* @param tBtnPort : ToogleButton
*/
public ChkBoxGridPane(Codierer codierer, int port, ToggleButton tBtnPort) {
this.codierer = codierer;
this.port = port;
this.tBtnPort = tBtnPort;
this.verfuegbareBuchstaben = this.codierer.fetchVerfuegbareBuchstaben(this.port).toCharArray();
Arrays.sort(this.verfuegbareBuchstaben);
charSize = this.verfuegbareBuchstaben.length;
this.checkedBuchstaben = tBtnPort.getText();
initializeComponents();
}
/**
* Es wird ein GridPane erzeugt, das zwei Spalten und abhängig von der Länge des
* Arrays (Character[] alphabet) Reihen hat. Das Label der CheckBoxen soll
* abhängig von deren Index links bzw. recht erzeugt werden
*/
private void initializeComponents() {
checkbox = new CheckBox[charSize];
this.setAlignment(Pos.CENTER);
// Für jeden verfügbaren Buchstaben einen Durchlauf
for (int i = 0; i < this.verfuegbareBuchstaben.length; i++) {
if (this.verfuegbareBuchstaben[i] != 20 && this.verfuegbareBuchstaben[i] != ' ') {
checkbox[i] = new CheckBox(this.verfuegbareBuchstaben[i] + "");
checkbox[i].setPadding(new Insets(1, 1, 1, 1));
if (!checkedBuchstaben.equals("")) {
if (!checkedBuchstaben.contains(String.valueOf(this.verfuegbareBuchstaben[i]))) {
checkbox[i].setDisable(true);
} else {
checkbox[i].setSelected(true);
}
} else {
checkbox[i].setSelected(false);
checkbox[i].setDisable(false);
}
// Der Listener für die jeweilige Checkbox
checkbox[i].selectedProperty().addListener((observable, oldValue, newValue) -> {
String portSelection = "";
int zaehler = 0;
// Die selektierten Chechkboxen zählen
for (CheckBox cb : checkbox) {
if (cb != null && cb.isSelected()) {
zaehler++;
}
}
// Wenn nur eine oder keine Checkbox ausgewählt ist
if (zaehler == 1 || zaehler == 0) {
for (CheckBox cb : checkbox) {
if (cb != null && cb.isDisabled()) {
cb.setDisable(false);
}
}
}
// Es ist keine Checkbox ausgewählt
if (zaehler == 0) {
// Daten ins Steckbrett schreiben
this.codierer.setzeSteckbrett(this.port, "");
// Und den Button neu beschreiben
tBtnPort.setText(portSelection);
}
// Das Maximum an selektierten Checkboxen (2) ist erreicht
if (zaehler == 2) {
for (CheckBox cb : checkbox) {
if (cb != null && !cb.isSelected()) {
cb.setDisable(true);
} else {
if (cb != null) {
portSelection += cb.getText();
}
}
}
// Daten ins Steckbrett schreiben
this.codierer.setzeSteckbrett(this.port, "");
this.codierer.setzeSteckbrett(this.port, portSelection);
// Und den Button neu beschreiben
tBtnPort.setText(portSelection);
}
});
// Eine neue Row im Gridpane anlegen für den nächsten Button
this.addRow(i + 1);
this.add(checkbox[i], 2, i + 1, 1, 1);
}
}
// Das Pane anzeigen
this.setVisible(true);
}
/**
* Gibt den Anzahl der zur Verfügung stehenden Buchstaben zurück.
* Anhang dieses Wertes, wird die Anzahl der Checkboxen festgelegt.
*
* @return int : Anzahl der möglcihen chars
*/
public int getCharSize() {
return charSize;
}
}
src/main/resources/projekt/enigma/codebuch.sqlite
View file @ 6cfa05da
No preview for this file type
src/main/resources/projekt/enigma/kenngruppe.fxml deleted 100644 → 0
View file @ b86f504c
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.VBox?>
<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="137.0" prefWidth="234.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="projekt.enigma.KenngruppeController">
<children>
<VBox layoutX="13.0" layoutY="20.0" prefHeight="107.0" prefWidth="209.0" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="13.0" AnchorPane.rightAnchor="12.0" AnchorPane.topAnchor="20.0">
<children>
<Label alignment="CENTER" contentDisplay="CENTER" prefHeight="17.0" prefWidth="208.0" text="Bitte Kenngruppe eingeben!" />
<Label prefHeight="62.0" prefWidth="209.0" />
<TextField fx:id="tfKenngruppe" />
<Label prefHeight="39.0" prefWidth="209.0" />
<Button maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" onAction="#btnGui" prefHeight="25.0" prefWidth="212.0" text="Kenngruppe setzen!" />
</children>
</VBox>
</children>
</AnchorPane>