Skip to content
Snippets Groups Projects
Commit 98ccff9f authored by Dennis Eisold's avatar Dennis Eisold
Browse files

Merge branch 'master' into 'master' 

Master

See merge request !45
parents 04dedbb8 e6a816e0
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/main/java/projekt/enigma/model/Codebuch.java
+ 31
− 15
View file @ 98ccff9f
......@@ -7,7 +7,7 @@ import java.time.ZoneId;
/**
* Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
* Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
* Jeder Enigma gehörte auch ein Codebuch bei, welches notwendig war um die Nachrichten zu ver/entschlüsseln.
* 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
......@@ -22,22 +22,36 @@ import java.time.ZoneId;
* geben kann.
*/
public class Codebuch {
/**
* TODO: Dokumentieren
* TODO: Dokumentieren tag
* tag : int : gibt den Tag an
*/
private int tag;
/**
* walzenlage : int[] : legt die Positionen der Walzen fest
*/
private int[] walzenlage;
/**
* ringstellung : int[] : TODO ringstellung: char || int ?
*/
private int[] ringstellung;
/**
* steckverbindung : char[][] : stellt die Steckverbindungen im Steckbrett dar
*/
private char[][] steckverbindung;
/**
* Im Konstruktor werden die Standart Werte 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
* die Kabel mit ihren jeweiligen Buchsen hinterlegt.
* die Kabel mit ihren jeweiligen Buchsen hinterlegt.
*/
public Codebuch() {
this.walzenlage = new int[3];
......@@ -53,12 +67,16 @@ public class Codebuch {
/**
* TODO: Dokumentieren
* @param tag
* 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
*/
public void fetchTagesschluessel(int... tag) {
String[] walzenlage, ringstellung, db;
if(tag.length > 0) {
if (tag.length > 0) {
db = new DatenbankSqlite().getCodebuch(tag[0]);
} else {
db = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
......@@ -82,7 +100,7 @@ public class Codebuch {
/**
* Gibt die aktuelle Instanz des Codebuches als String zurück.
* Hierbei werden der Tag die Walzenlagen, Ring/Grundstellung sowie die Steckverbindungen zurück gegeben.
* Hierbei werden der Tag die Walzenlagen, Ring-/Grundstellung sowie die Steckverbindungen zurück gegeben.
*
* @return String : String des gesamten Objektes
*/
......@@ -138,16 +156,14 @@ public class Codebuch {
/**
* Setzt den Tag dieser Instanz
*
* @param tag : int
* @param tag : int : Tag
*/
void setTag(int tag) {
this.tag = tag;
}
void setTag(int tag) { this.tag = tag; }
/**
* Gibt die Walzenlage dieser Instanz zurück
*
* @return String[] : Walzenlage
* @return String[] : Walzenlage TODO: String[] || int[]?
*/
public int[] getWalzenlage() {
return walzenlage;
......@@ -156,7 +172,7 @@ public class Codebuch {
/**
* Gibt die Ringstellung dieser Instanz zurück
*
* @return String[] : Ringstellung
* @return String[] : Ringstellung TODO: String[] || int[]?
*/
public int[] getRingstellung() {
return ringstellung;
......@@ -177,7 +193,7 @@ public class Codebuch {
*
* @param kabel : String[] : Die Steckverbindungen die gesteckt werden sollen.
* Jeder Eintrag im Array ist ein String mit zwei Zeichen.
* Diese werden in zwei char zerlegt und anschließend im globalen
* Diese werden in zwei chars zerlegt und anschließend im globalen
* Array gespeichert.
*/
private void setSteckverbindung(String[] kabel) {
......@@ -205,7 +221,7 @@ public class Codebuch {
* 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.
* @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;
......
src/main/java/projekt/enigma/model/Walze.java
+ 240
− 219
View file @ 98ccff9f
......@@ -2,246 +2,267 @@ package projekt.enigma.model;
/**
* Klasse Walze
* <p>
* <br>
* Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
* <p>
* <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)
* <p>
* <br>
* 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
* den Drehzeitpunkt der linken Nachbarwalze)
*/
public class Walze {
/**
* Konstanten und Variablen der Klasse Walze
* <p>
* ringstellung : Bestimmt den Umspringpunkt der Walze
* walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
*/
private Character[] walzeAlpha;
private char ringstellung;
private int walzennr;
private Character[] alphabet;
/**
* Gibt die Parameter der Walze mit
*
* @param walzennr : int : Nummer der gewaehlten Walze
* @param ringstellung : Character : Einstellung des Notch
*/
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'};
// Setzen der Walzennummer
this.setWalzennr(walzennr);
// Setzen der Ringstellung
this.setRingstellung(ringstellung);
}
/**
* Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
*
* @return walze : Character[] : gibt die gewaehlte Walze zurueck
*/
private Character[] walzenNummer() {
Character[] walze = new Character[26];
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 : Character : gibt die neue Ringstellung zurueck
*/
public char getRingstellung() {
return ringstellung;
}
/**
* Gibt die Initiale Ringstellung der Walze an.
* Es sind nur Zahlen von 1 - 26 zugelassen.
* Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
*
* @param ringstellung : Character : Punkt an dem die Walze umspringt
*/
public void setRingstellung(int ringstellung) {
if (ringstellung > 0 && ringstellung <= 26) {
this.ringstellung = this.alphabet[ringstellung - 1];
} else {
this.ringstellung = 'Z';
}
}
/**
* dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
* TODO: Doku
*/
public boolean dreheWalze(int... drehung) {
boolean checkRing = false;
verschiebung();
if (drehung.length > 0) {
for (int i = 1; i < drehung[0]; i++) {
verschiebung();
}
}
if (this.getPosition().equals(this.ringstellung)) {
checkRing = true;
}
return checkRing;
}
/**
* walzeAlpha : Character[] : Array, dass die Buchstaben des Alphabets enthaelt
*/
private Character[] alphabet;
/**
* TODO: Dokumentieren
* ringstellung : char : zeigt die Einstellung fuer den Umspringpunkt
*/
private void verschiebung() {
Character[] neueWalze = new Character[26];
for (int index = 0; index < neueWalze.length; index++) {
neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index];
}
this.walzeAlpha = neueWalze;
}
private char ringstellung;
/**
* TODO: Dokumentieren
* TODO: Ich glaube das kann weg?
*
* @return
* walzennr : int : Bestimmt, welche Walze genutzt wird
*/
public char getAnzeige() {
int temp = this.getArrayIndex('A', this.walzeAlpha);
return this.alphabet[temp];
}
private int walzennr;
/**
* Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
* anhand der gewaehlten Walze.
*
* @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
* alphabet : Character[] : Enthaelt die Buchstaben des Alphabets. Wird im Laufe des Programmes
* aber immer wieder ueberschrieben.
*/
public char codiere(char buchstabe) {
for (int i = 0; i < walzeAlpha.length; i++) {
if (walzeAlpha[i].equals(buchstabe)) {
buchstabe = walzenNummer()[i];
break;
}
}
return buchstabe;
}
/**
* Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
* anhand der AlphaWalze.
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.
*
* @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
*/
public char codiere2(char buchstabe) {
for (int i = 0; i < walzenNummer().length; i++) {
if (walzenNummer()[i].equals(buchstabe)) {
buchstabe = walzeAlpha[i];
break;
}
}
return buchstabe;
}
/**
* TODO: Dokumentieren
* 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.
*
* @param buchstabe : Character
* @param array : Character[]
* @return int
*/
private int getArrayIndex(Character buchstabe, Character[] array) {
int result = -1;
for (int i = 0; i < array.length; i++) {
if (array[i].equals(buchstabe)) {
result = i;
break;
}
}
return result;
}
/**
* Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
* Ueberprueft, ob der Umspringpunkt der Walze nach der Drehung erreicht wurde.
*
* @param walzennr : int : setzt die Walzennummer
*/
public void setWalzennr(int walzennr) {
if (walzennr > 0 && walzennr < 6) {
this.walzennr = walzennr;
} else {
System.err.println("Keine gültige Walzennummer");
}
}
/**
* TODO: Dokumentieren
* @param drehung : int[] : Anzahl der Drehungen
* @return checkRing : boolean : gibt true zurueck wenn der Umspringpunkt erreicht wurde
* TODO: Doku
*/
public boolean dreheWalze(int... drehung) {
boolean checkRing = false;
// fuehrt die Verschiebung des Alphabets um eine Stelle durch
verschiebung();
// fuehrt die Verschiebung mehrfach aus, wenn mehrere Drehungen ausgefuehrt werden sollen
if (drehung.length > 0) {
for (int i = 1; i < drehung[0]; i++) {
verschiebung();
}
}
// gleicht die Ringstellung mit der aktuellen Position ab
if (this.getPosition().equals(this.ringstellung)) {
checkRing = true;
}
return checkRing;
}
/**
* Ueberschreibt die Alphabetswalze mit dem, durch die Drehung, verschobenen Alphabet.
* TODO: Dokumentieren
*/
private void verschiebung() {
Character[] neueWalze = new Character[26];
for (int index = 0; index < neueWalze.length; index++) {
neueWalze[(index + 1) % neueWalze.length] = this.walzeAlpha[index];
}
this.walzeAlpha = neueWalze;
}
/**
* TODO: Dokumentieren // dass selbe wie getPosition
* Gibt den Buchstaben zurueck der in der Walze aktuell eingestellt ist.
*
* @return Character
*/
public Character getPosition() {
return walzeAlpha[0];
}
/**
* Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
* Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
* Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
* TODO: Funktionsname hat sich geändert
* @return char an der Stelle temp des Alphabets
*/
public char getAnzeige() {
int temp = this.fetchArrayIndex('A', this.walzeAlpha);
return this.alphabet[temp];
}
/**
* Codiert den mitgegebenen Buchstaben anhand der gewaehlten Walze.
*
* @param buchstabe : char : Buchstabe, der verschluesselt werden soll
* @return buchstabe : char : verschluesselter Buchstabe
*/
public char codiere(char buchstabe) {
/* 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 : Grundeinstellung 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.getArrayIndex(buchstabe, this.alphabet));
}
}
}
* @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));
}
}
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment