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

Merge branch 'master' into 'master' 

Walzen überarbeitet und jetzt dreht die Scheiße richtig -.-

See merge request alfatrainingkurse/java/enigma!29
parents 036323c8 56edd942
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/main/java/Enigma/model/Hardware.java
+ 19
− 12
View file @ b2f197ac
package Enigma.model;
import org.apache.http.HttpException;
import java.io.IOException;
import java.util.Random;
/**
* In dieser Klasse wird die Hardware zusammen gefasst.
* Alle Komponenter der Enigma laufen hier zusammen.
......@@ -59,7 +54,7 @@ public class Hardware {
* @param buchstabe : char : Buchstabe der zugewiesen soll
*/
public void setzePosition(int walze, char buchstabe) {
this.walzen[walze].setBuchstabe(buchstabe);
this.walzen[walze].setPosition(buchstabe);
}
/**
......@@ -69,17 +64,29 @@ public class Hardware {
* @return char : Der ver/entschlüsselte Buchstabe
*/
public char codiere(char buchstabe) {
System.out.println(this.walzen[2].getPosition());
this.dreheWalzen();
System.out.println(this.walzen[2].getPosition());
System.out.print(buchstabe);
buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
buchstabe = this.walzen[0].codiere(buchstabe);
buchstabe = this.walzen[1].codiere(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.walzen[2].codiere(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.walzen[1].codiere(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.walzen[0].codiere(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.reflektor.codiere(buchstabe);
buchstabe = this.walzen[2].codiere2(buchstabe);
buchstabe = this.walzen[1].codiere2(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.walzen[0].codiere2(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.walzen[1].codiere2(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.walzen[2].codiere2(buchstabe);
System.out.print(" : " + buchstabe);
buchstabe = this.steckbrett.codiere(buchstabe);
System.out.println(" : " + buchstabe);
return buchstabe;
}
......@@ -89,9 +96,9 @@ public class Hardware {
* Hier überprüfen wir welche der Walzen gedreht werden müssen und stoßen die Vorgang an.
*/
private void dreheWalzen() {
if (this.walzen[0].dreheWalze()) {
if (this.walzen[2].dreheWalze()) {
if (this.walzen[1].dreheWalze()) {
this.walzen[2].dreheWalze();
this.walzen[0].dreheWalze();
}
}
}
......
src/main/java/Enigma/model/Reflektor.java
+ 1
− 0
View file @ b2f197ac
......@@ -44,6 +44,7 @@ public class Reflektor {
break;
}
}
/*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
return WALZE_REFLEKTOR[iPositionReflektor];
}
......
src/main/java/Enigma/model/Steckbrett.java
+ 6
− 6
View file @ b2f197ac
package Enigma.model;
/**
*
*TODO Dokumentieren
*/
public class Steckbrett {
/**
*
*TODO Dokumentieren
*/
private int zaehler;
private Character[] orginalBuchstaben;
private Character[] getauschteBuchstaben;
/**
*
*TODO Dokumentieren
*/
public Steckbrett() {
......@@ -22,7 +22,7 @@ public class Steckbrett {
/**
*
*TODO Dokumentieren
* @param buchstabe1
* @param buchstabe2
* @return
......@@ -40,7 +40,7 @@ public class Steckbrett {
}
/**
*
*TODO Dokumentieren
* @return
*/
public boolean ueberpruefeVertauschungen() {
......@@ -57,7 +57,7 @@ public class Steckbrett {
}
/**
*
* TODO Dokumentieren
* @param buchstabe
* @return
*/
......
src/main/java/Enigma/model/Walze.java
+ 73
− 38
View file @ b2f197ac
package Enigma.model;
import java.time.Year;
/**
* Klasse Walze
* <p>
......@@ -27,13 +25,12 @@ public class Walze {
* private Character[] walze : Character-Array der Walze
*/
/*Alphawalze*/
private final static Character[] walzeAlpha = {'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'};
private Character[] walzeAlpha;
private Character buchstabe;
private int ringstellung;
private char ringstellung;
private int walzennr;
private int iPositionBuchstabe;
private int verschoben;
private Character[] walze;
private Character[] alphabet;
/**
......@@ -43,12 +40,12 @@ public class Walze {
* @param ringstellung : Character : Einstellung des Notch
*/
public Walze(int walzennr, int ringstellung) {
this.walze = new Character[26];
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.walzennr = walzennr;
this.buchstabe = 'A';
this.iPositionBuchstabe = 0;
this.verschoben = 0;
this.ringstellung = ringstellung;
this.ringstellung = this.alphabet[ringstellung - 1];
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'};
}
......@@ -58,11 +55,10 @@ public class Walze {
* @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'};
......@@ -88,6 +84,10 @@ public class Walze {
}
/**
* TODO Dokumentieren
* @return
*/
//walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
public char walzenPosition() {
......@@ -102,9 +102,10 @@ public class Walze {
// Setter für Ringstellung
/**
* TODO Dokumentieren
* @return ringstellung : Character : gibt die neue Ringstellung zurueck
*/
public int getRingstellung() {
public char getRingstellung() {
return ringstellung;
}
......@@ -118,39 +119,48 @@ public class Walze {
public void setRingstellung(int ringstellung) {
if (ringstellung > 0 && ringstellung <= 26) {
this.ringstellung = ringstellung;
this.ringstellung = this.alphabet[ringstellung - 1];
} else {
this.ringstellung = 1;
this.ringstellung = 'Z';
}
}
//dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
public boolean dreheWalze() {
/**
* dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
* TODO Doku
*/
public boolean dreheWalze(int... args) {
boolean checkRing;
boolean checkRing = false;
if (this.iPositionBuchstabe == 25) {
this.iPositionBuchstabe = 0;
if (args[0] > 1) {
for (int i = 0; i < args[0]; i++) {
verschiebung();
}
} else {
this.iPositionBuchstabe += 1;
verschiebung();
}
checkRing = this.iPositionBuchstabe == (getRingstellung() - 1);
setPosition(walzeAlpha[0]);
setBuchstabe(walzeAlpha[iPositionBuchstabe]);
if(this.getPosition().equals(this.ringstellung)) {
checkRing = true;
}
return checkRing;
}
public int verschiebung(int i) {
/**
* TODO Dokumentieren
*/
public void verschiebung() {
if((i + iPositionBuchstabe) >= 26) {
int verschoben = (i + iPositionBuchstabe) - 26 ;
} else {
verschoben = i + iPositionBuchstabe;
Character[] neueWalze = new Character[26];
for (int index = 0; index < 25; index++) {
neueWalze[index + 1] = this.walzeAlpha[index];
}
return verschoben;
neueWalze[0] = this.walzeAlpha[25];
this.walzeAlpha = neueWalze;
}
......@@ -164,7 +174,7 @@ public class Walze {
for (int i = 0; i < walzeAlpha.length; i++) {
if (walzeAlpha[i].equals(buchstabe)) {
buchstabe = walzenNummer()[verschiebung(i)];
buchstabe = walzenNummer()[i];
break;
}
}
......@@ -180,10 +190,9 @@ public class Walze {
* @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[verschiebung(i)];
buchstabe = walzeAlpha[i];
break;
}
}
......@@ -195,6 +204,7 @@ public class Walze {
/**
* TODO Dokumentieren
* @return buchstabe : Character : gibt den neuen Buchstaben zurueck
*/
public Character getBuchstabe() {
......@@ -205,24 +215,41 @@ public class Walze {
* 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
*
* @param buchstabe : Character : Grundeinstellung der Walze
*/
public void setBuchstabe(Character buchstabe) {
public void setPosition(Character buchstabe) {
if (Character.isLetter(buchstabe)) {
this.buchstabe = Character.toUpperCase(buchstabe);
for (int i = 0; i < 25; i++) {
if (walzeAlpha[i].equals(buchstabe)) {
this.iPositionBuchstabe = i;
}
}
System.arraycopy(this.alphabet, 0, this.walzeAlpha, 0, this.alphabet.length);
dreheWalze(this.getArrayIndex(buchstabe, this.alphabet) + 1);
} else {
this.buchstabe = 'A';
}
}
/**
* TODO Dokumentieren
* @param buchstabe
* @param array
* @return
*/
public int getArrayIndex(Character buchstabe, Character[] array) {
int result = -1;
for (int i = 0; i < array.length; i++) {
if (array[i].equals(buchstabe)) {
result = i;
}
}
return result;
}
//TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
// Überprüfung sollte in walzenNummer() statt finden.
/**
* Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
......@@ -237,4 +264,12 @@ public class Walze {
}
}
/**
* TODO: Dokumentieren
*
* @return
*/
public Character getPosition() {
return walzeAlpha[0];
}
}
src/test/java/Enigma/model/HardwareTest.java
+ 17
− 19
View file @ b2f197ac
......@@ -15,37 +15,35 @@ public class HardwareTest {
h.setWalzen(2, 3, 1);
/*
A = E = S = G = Y = O = Y = O
I = V = Y = Q = O = Z = S = S
F = G = R = W = K = U = H = P
In S 1 2 3 R 3 2 1 S
A E D H X S Z J
J Z E J B D K N
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 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'};
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 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 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'};
*/
char result = h.codiere('A');
Assert.assertEquals("Codiere: Erwartet O, erhalten "+ result, 'O', result);
char result;
result = h.codiere('A');
Assert.assertEquals("Codiere: A Erwartet P, erhalten "+ result, 'P', result);
result = h.codiere('B');
Assert.assertEquals("Codiere: B Erwartet R, erhalten "+ result, 'R', result);
result = h.codiere('I');
Assert.assertEquals("Codiere: Erwartet S, erhalten "+ result, 'S', result);
Assert.assertEquals("Codiere: I Erwartet E, erhalten "+ result, 'E', result);
result = h.codiere('F');
Assert.assertEquals("Codiere: Erwartet P, erhalten "+ result, 'P', result);
Assert.assertEquals("Codiere: F Erwartet A, erhalten "+ result, 'A', result);
result = h.codiere('O');
Assert.assertEquals("Decodiere: Erwartet A, erhalten "+ result, 'A', result);
result = h.codiere('S');
Assert.assertEquals("Decodiere: Erwartet I, erhalten "+ result, 'I', result);
h.getWalzen()[2].setPosition('A');
result = h.codiere('P');
Assert.assertEquals("Decodiere: Erwartet F, erhalten "+ result, 'F', result);
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.getSteckbrett().setzeVertauschung('B', 'G');
h.getSteckbrett().setzeVertauschung('D', 'F');
......
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