dergeorg/SWE1-MTCG
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge 'dev' v1

Browse Source
This commit is contained in:
Georg Reisinger 2021-01-02 15:24:46 +01:00
commit 6c59901d2b
28 changed files with 3575 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
.gitignore vendored Normal file
View File

@ -0,0 +1,26 @@
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# at.reisinger.obj.Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
.idea/compiler.xml
*.lst
.idea/

124
.idea/uiDesigner.xml generated Normal file
View File

@ -0,0 +1,124 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Palette2">
<group name="Swing">
<item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
</item>
<item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
</item>
<item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
</item>
<item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.png" removable="false" auto-create-binding="false" can-attach-label="true">
<default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
</item>
<item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
<initial-values>
<property name="text" value="Button" />
</initial-values>
</item>
<item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
<initial-values>
<property name="text" value="RadioButton" />
</initial-values>
</item>
<item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
<initial-values>
<property name="text" value="CheckBox" />
</initial-values>
</item>
<item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
<initial-values>
<property name="text" value="Label" />
</initial-values>
</item>
<item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
<preferred-size width="150" height="-1" />
</default-constraints>
</item>
<item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
<preferred-size width="150" height="-1" />
</default-constraints>
</item>
<item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
<preferred-size width="150" height="-1" />
</default-constraints>
</item>
<item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
</item>
<item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
<preferred-size width="150" height="50" />
</default-constraints>
</item>
<item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
<preferred-size width="200" height="200" />
</default-constraints>
</item>
<item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
<preferred-size width="200" height="200" />
</default-constraints>
</item>
<item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.png" removable="false" auto-create-binding="true" can-attach-label="true">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
</item>
<item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
</item>
<item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
</item>
<item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
</item>
<item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
<preferred-size width="-1" height="20" />
</default-constraints>
</item>
<item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.png" removable="false" auto-create-binding="false" can-attach-label="false">
<default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
</item>
<item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
<default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
</item>
</group>
</component>
</project>

2
README.md Normal file
View File

@ -0,0 +1,2 @@
# SWE1-MTCG
Monster Trading at.reisinger.obj.Card Game

47
pom.xml Normal file
View File

@ -0,0 +1,47 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>at.reisinger.mtcg</groupId>
<artifactId>MTCG</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>11</source>
<target>11</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>RELEASE</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.5.13</version>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-junit-jupiter</artifactId>
<version>3.5.13</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.2</version>
</dependency>
</dependencies>
</project>

5
src/main/java/at/reisinger/enums/CardType.java Normal file
View File

@ -0,0 +1,5 @@
package at.reisinger.enums;
public enum CardType {
MONSTER, SPELL, UNDEF, GOBLIN, TROLL, ELF, KNIGHT, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES
}

5
src/main/java/at/reisinger/enums/ElementTyp.java Normal file
View File

@ -0,0 +1,5 @@
package at.reisinger.enums;
public enum ElementTyp {
WATER, FIRE, NORMAL, UNDEF, REGULAR, FEUER, WASSER
}

493
src/main/java/at/reisinger/obj/Battle.java Normal file
View File

@ -0,0 +1,493 @@
package at.reisinger.obj;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Objects;
public class Battle {
private final User player1;
private User player2;
private int scorePlayer1;
private int scorePlayer2;
private final int id;
private Cards deckPlayer1;
private Cards deckPlayer2;
private final Cards deckPlayer1Init;
private Cards deckPlayer2Init;
private final ArrayList<String> log = new ArrayList<>();
/**
* Erstellt ein neues Battle, im zustand offenes battle
* @param id Id des Battles
* @param player1 Player 1 des Battles
* @param deckPlayer1 Deck vom Player 1 als json
*/
public Battle(int id, User player1, Cards deckPlayer1){
this.id = id;
this.player1 = player1;
this.deckPlayer1 = deckPlayer1;
this.scorePlayer1 = 100;
this.scorePlayer2 = 100;
this.deckPlayer2 = null;
this.deckPlayer1Init = deckPlayer1;
this.deckPlayer2Init = null;
}
/**
* Startet einen Kampf zw den beiden Playern
* @return true bei erfolg, sonst false
*/
public boolean doFight(){
System.out.println(player1.getName() + " |vs|" + player2.getName());
if(deckPlayer1.getCards().size() == 4 && deckPlayer2.getCards().size() == 4) {
//SHUFFLE DECK
ArrayList<Card> d1 = deckPlayer1.getCards();
ArrayList<Card> d2 = deckPlayer2.getCards();
Collections.shuffle(d1);
Collections.shuffle(d2);
deckPlayer1.setCards(d1);
deckPlayer1.setCards(d2);
//Runden
int maxroundcount = 100, counter = 0, counter2 = 0;
while(counter<maxroundcount) {
counter++;
counter2++;
if(counter2 < d1.size()-1 || counter2 < d2.size()-1){
counter2 = 0;
}
if (d1.size() > 0 && d2.size() > 0 && counter<=maxroundcount) {
System.out.println("Runde: " + counter);
System.out.println("deck 1 size: " + d1.size() + " Deck 2 size: " + d2.size() + " counter2: " + counter2);
Card c1 = d1.get(counter2);
Card c2 = d2.get(counter2);
System.out.println("Card 1: " + c1.getElementTyp() + c1.getCardType() + "\nCard 2: " + c2.getElementTyp() + c2.getCardType());
//GLEICHER TYP Monster
if (!c1.getCardType().name().equalsIgnoreCase("SPELL") && !c2.getCardType().name().equalsIgnoreCase("SPELL")) {
System.out.println("Same Monster");
//Check ob eine der beiden Carten ein Dragon ist
if ((c1.getCardType().name().equalsIgnoreCase("DRANGON") && !c2.getCardType().name().equalsIgnoreCase("DRANGON") || (!c1.getCardType().name().equalsIgnoreCase("DRANGON") && c2.getCardType().name().equalsIgnoreCase("DRANGON")))) {
//Eine der Karten is Dragon
System.out.println("Eine ist ein dragon");
Card dragon;
int dragonOwner;
if (c1.getCardType().name().equalsIgnoreCase("DRAGON")) {
dragon = c1;
dragonOwner = 1;
} else if (c2.getCardType().name().equalsIgnoreCase("DRAGON")) {
dragon = c2;
dragonOwner = 2;
} else {
System.out.println("KEIN DRAGON GEFUNDEN");
return false;
}
if ((c1.getCardType().name().equalsIgnoreCase("GOBLIN") && !c2.getCardType().name().equalsIgnoreCase("GOBLIN") || (!c1.getCardType().name().equalsIgnoreCase("GOBLIN") && c2.getCardType().name().equalsIgnoreCase("GOBLIN")))) {
//Eine der Karten ist Goblin
System.out.println("Andere ist ein goblin");
Card goblin;
if (c1.getCardType().name().equalsIgnoreCase("GOBLIN")) {
goblin = c1;
} else if (c2.getCardType().name().equalsIgnoreCase("GOBLIN")) {
goblin = c2;
} else {
System.out.println("KEIN GOBLIN GEFUNDEN");
return false;
}
if (dragon.getDamage() > goblin.getDamage()) {
//Drache ist stärker
if (dragonOwner == 1) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer1 -= 5;
this.scorePlayer2 += 3;
}
log.add("Player " + dragonOwner + " gewinnt!\nDrache ist stärker! Drache: " + dragon.getDamage() + " vs Goblin: " + goblin.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else {
System.out.println("DRAW: Drache zu schwach um anzugreifen und GOBLIN zu feige.");
}
} else if ((c1.getCardType().name().equalsIgnoreCase("ELF") && c1.getElementTyp().name().equalsIgnoreCase("FIRE") && !c2.getCardType().name().equalsIgnoreCase("ELF") || (!c1.getCardType().name().equalsIgnoreCase("ELF") && c2.getElementTyp().name().equalsIgnoreCase("FIRE") && c2.getCardType().name().equalsIgnoreCase("ELF")))) {
//Eine der Karten ist der Fire Elf die andere Karte ist der drache
System.out.println("Andere ist ein elf");
Card fireelf;
if (dragonOwner == 1) {
fireelf = c2;
} else {
fireelf = c1;
}
if (fireelf.getDamage() > dragon.getDamage()) {
//Fireelf ist stärker
if (dragonOwner == 1) {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
} else {
d1.add(c2);
d2.remove(c2);
this.scorePlayer2 -= 5;
this.scorePlayer1 += 3;
}
log.add("Player " + dragonOwner + " gewinnt!\nWizzard ist stärker! Drache: " + dragon.getDamage() + " vs FireElves: " + fireelf.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
//Sonst nix tun, weil der drache den elf ned angreifen kann
} else {
if (c1.getDamage() > c2.getDamage()) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else if (c1.getDamage() < c2.getDamage()) {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
}
//Checkt ob eine der beiden karten ein wizzard ist und der andere ein ork
} else if ((c1.getCardType().name().equalsIgnoreCase("WIZZARD") && c2.getCardType().name().equalsIgnoreCase("ORK") || (c2.getCardType().name().equalsIgnoreCase("WIZZARD") && c1.getCardType().name().equalsIgnoreCase("ORK")))) {
System.out.println("Eine wizzard Andere ist ein ork");
Card wizzard = null;
Card ork = null;
int wizzardOwner = 0;
if (c1.getCardType().name().equalsIgnoreCase("WIZZARD")) {
wizzardOwner = 1;
wizzard = c1;
ork = c2;
} else if (c2.getCardType().name().equalsIgnoreCase("WIZZARD")) {
wizzardOwner = 2;
wizzard = c2;
ork = c1;
}
if (wizzard != null && wizzard.getDamage() > ork.getDamage()) {
if (wizzardOwner == 1) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
}
log.add("Player " + wizzardOwner + " gewinnt!\nWizzard ist stärker! Wizzard: " + wizzard.getDamage() + " vs Ork: " + ork.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
//Sonst nix tun, weil der ork dem wizzard keinen schaden machen kann
} else {
//PURE MONSTER
if (c1.getDamage() > c2.getDamage()) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else if (c1.getDamage() < c2.getDamage()) {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
//sonst nix weil bei gleichen damage --> draw
}
} else {//PURE SPELL & mixed
double damagePlayer1 = -1, damagePlayer2 = -1;
if (c1.getCardType().name().equalsIgnoreCase("KNIGHT") || c2.getCardType().name().equalsIgnoreCase("KNIGHT")) {
//Mixed mit "Spezialeffekt" KNIGHT
System.out.println("Spell und knight");
Card knight = null, other = null;
int knightOwner = 0;
if (c1.getCardType().name().equalsIgnoreCase("KNIGHT")) {
knight = c1;
other = c2;
knightOwner = 1;
} else if (c2.getCardType().name().equalsIgnoreCase("KNIGHT")) {
knight = c2;
other = c1;
knightOwner = 2;
}
double damageKnight = -1, damageOther = -1;
if (Objects.requireNonNull(other).getElementTyp().name().equalsIgnoreCase("WATER")) {
//tot
damageKnight = 0;
damageOther = other.getDamage();
} else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("REGULAR")) {
//not effective
damageKnight = knight.getDamage() / 2;
//effective
damageOther = other.getDamage() * 2;
} else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("FIRE")) {
//no effect
damageKnight = knight.getDamage();
//no effect
damageOther = other.getDamage();
} else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("WATER")) {
//effective
damageKnight = knight.getDamage() * 2;
//not effective
damageOther = other.getDamage() / 2;
} else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("REGULAR")) {
//no effect
damageKnight = knight.getDamage();
//no effect
damageOther = other.getDamage();
} else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("FIRE")) {
//effective
damageKnight = knight.getDamage() * 2;
//not effective
damageOther = other.getDamage() / 2;
} else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("WATER")) {
//not effective
damageKnight = knight.getDamage() / 2;
//effective
damageOther = other.getDamage() * 2;
}
if (damageKnight > damageOther) {
if (knightOwner == 1) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damageKnight + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
} else if (damageKnight < damageOther) {
if (knightOwner == 2) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageOther + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
}
} else if (c1.getCardType().name().equalsIgnoreCase("KRAKEN") || c2.getCardType().name().equalsIgnoreCase("KRAKEN")) {
//Mixed mit "Spezialeffekt" KRAKEN
if (c1.getCardType().name().equalsIgnoreCase("KRAKEN")) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else if (c2.getCardType().name().equalsIgnoreCase("KRAKEN")) {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
} else {
////PURE SPELL & mixed mit elementen
System.out.println("Spell und mixed mit elementen");
//Player 1 Damage berechnen
switch (c1.getElementTyp().name().toUpperCase()) {
case "FIRE":
switch (c2.getElementTyp().name().toUpperCase()) {
case "REGULAR":
//effective
damagePlayer1 = c1.getDamage() * 2;
break;
case "WATER":
//not effective
damagePlayer1 = c1.getDamage() / 2;
break;
case "FIRE":
//no effect
damagePlayer1 = c1.getDamage();
break;
}
break;
case "WATER":
switch (c2.getElementTyp().name().toUpperCase()) {
case "FIRE":
//effective
damagePlayer1 = c1.getDamage() * 2;
break;
case "WATER":
//no effect
damagePlayer1 = c1.getDamage();
break;
case "REGULAR":
//not effective
damagePlayer1 = c1.getDamage() / 2;
break;
}
break;
case "REGULAR":
switch (c2.getElementTyp().name().toUpperCase()) {
case "WATER":
//effective
damagePlayer1 = c1.getDamage() * 2;
break;
case "FIRE":
//not effective
damagePlayer1 = c1.getDamage() / 2;
break;
case "REGULAR":
//no effect
damagePlayer1 = c1.getDamage();
break;
}
break;
}
//P2 damage
switch (c2.getElementTyp().name().toUpperCase()) {
case "FIRE":
switch (c1.getElementTyp().name().toUpperCase()) {
case "REGULAR":
//effective
damagePlayer2 = c2.getDamage() * 2;
break;
case "WATER":
//not effective
damagePlayer2 = c2.getDamage() / 2;
break;
case "FIRE":
//no effect
damagePlayer2 = c2.getDamage();
break;
}
break;
case "WATER":
switch (c1.getElementTyp().name().toUpperCase()) {
case "FIRE":
//effective
damagePlayer2 = c2.getDamage() * 2;
break;
case "WATER":
//no effect
damagePlayer2 = c2.getDamage();
break;
case "REGULAR":
//not effective
damagePlayer2 = c2.getDamage() / 2;
break;
}
break;
case "REGULAR":
switch (c1.getElementTyp().name().toUpperCase()) {
case "WATER":
//effective
damagePlayer2 = c2.getDamage() * 2;
break;
case "FIRE":
//not effective
damagePlayer2 = c2.getDamage() / 2;
break;
case "REGULAR":
//no effect
damagePlayer2 = c2.getDamage();
break;
}
break;
}
if (damagePlayer1 > -1 && damagePlayer2 > -1) {
if (damagePlayer1 > damagePlayer2) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damagePlayer1 + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damagePlayer2 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else if (damagePlayer2 > damagePlayer1) {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damagePlayer2 + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damagePlayer1 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
}
} else {
System.out.println("Damage konnte nicht berechnet werden");
return false;
}
}
}
}else {
return true;
}
}
this.deckPlayer1 = new Cards(d1);
this.deckPlayer2 = new Cards(d2);
}else{
System.out.println("Einer der Spieler hat zu wenige Karten im Deck");
return false;
}
return true;
}
public ArrayList<String> getLog() {
return log;
}
public int getId() {
return id;
}
public User getPlayer1() {
return player1;
}
public User getPlayer2() {
return player2;
}
public void setPlayer2(User player2) {
this.player2 = player2;
}
public int getScorePlayer1() {
return scorePlayer1;
}
public int getScorePlayer2() {
return scorePlayer2;
}
public Cards getDeckPlayer1() {
return deckPlayer1;
}
public Cards getDeckPlayer2() {
return deckPlayer2;
}
public void setDeckPlayer2(Cards deckPlayer2) {
this.deckPlayer2 = deckPlayer2;
this.deckPlayer2Init = deckPlayer2;
}
public Cards getDeckPlayer1Init() {
return deckPlayer1Init;
}
public Cards getDeckPlayer2Init() {
return deckPlayer2Init;
}
}

176
src/main/java/at/reisinger/obj/Card.java Normal file
View File

@ -0,0 +1,176 @@
package at.reisinger.obj;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
import at.reisinger.server.helper.EnumHelper;
import com.fasterxml.jackson.annotation.*;
import java.util.Objects;
/**
* Object einer at.reisinger.obj.Card
*/
@JsonAutoDetect
public class Card {
@JsonProperty
private String name;
@JsonProperty
private double damage;
@JsonProperty
private ElementTyp elementTyp;
@JsonProperty
private final CardType cardType;
@JsonProperty
private boolean locked;
/**
* Erstellt eine neue at.reisinger.obj.Card mit gegebenen Eigenschaften
* @param name Name der at.reisinger.obj.Card
* @param damage Damage den die at.reisinger.obj.Card macht
* @param elementTyp ElementType der at.reisinger.obj.Card
* @param cardType at.reisinger.enums.CardType der at.reisinger.obj.Card
*/
public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) {
this.name = name;
this.damage = damage;
this.elementTyp = elementTyp;
this.cardType = cardType;
}
/**
* Erstellt eine neue Card mit, anhand des cardNamen werden der ElementType und der CardType automatisch bestimmt
* @param name Name der Card (ID)
* @param elementCardTyp ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
* Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
* @param damage Damage der Card
*/
@JsonCreator
public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
ElementTyp tmpElement = null;
if(tmpCard == null){
tmpCard = CardType.UNDEF;
}
//Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen
switch (tmpCard.name().toLowerCase()) {
case "dragon":
case "fireelves":
tmpElement = ElementTyp.FIRE;
break;
case "ork":
case "wizzard":
case "knight":
case "troll":
case "goblin":
case "elf":
tmpElement = ElementTyp.REGULAR;
break;
case "kraken":
tmpElement = ElementTyp.WATER;
break;
}
if(tmpElement == null){
tmpElement = EnumHelper.stringToElementType(elementCardTyp);
//Deutsch übersetzung
switch (Objects.requireNonNull(tmpElement).name().toLowerCase()) {
case "feuer":
tmpElement = ElementTyp.FIRE;
break;
case "wasser":
tmpElement = ElementTyp.WATER;
break;
case "normal":
tmpElement = ElementTyp.REGULAR;
break;
}
}
this.name = name;
this.damage = damage;
this.elementTyp = tmpElement;
this.cardType = tmpCard;
}
public boolean isLocked() {
return locked;
}
public void setLocked(boolean locked) {
this.locked = locked;
}
/**
* Holt den Namen der at.reisinger.obj.Card
* @return Name der at.reisinger.obj.Card
*/
@JsonGetter
public String getName() {
return this.name;
}
/**
* Holt den Damage der at.reisinger.obj.Card
* @return Damage der at.reisinger.obj.Card
*/
@JsonGetter
public double getDamage() {
return this.damage;
}
/**
* Holt den ElementType der at.reisinger.obj.Card
* @return ElementType der at.reisinger.obj.Card
*/
@JsonGetter
public ElementTyp getElementTyp() {
return this.elementTyp;
}
/**
* Holt den at.reisinger.enums.CardType der at.reisinger.obj.Card
* @return at.reisinger.enums.CardType der at.reisinger.obj.Card
*/
@JsonGetter
public CardType getCardType() {
return this.cardType;
}
/**
* Setztden namen der at.reisinger.obj.Card
* @param neuerName Name der at.reisinger.obj.Card
*/
@JsonSetter
public void setName(String neuerName) {
this.name = neuerName;
}
/**
* Setzt den Damage der at.reisinger.obj.Card
* @param damage Der Damage
*/
@JsonSetter
public void setDamage(int damage) {
this.damage = damage;
}
/**
* Setzt den ElementType der at.reisinger.obj.Card
* @param elementTyp Der ElementType
*/
@JsonSetter
public void setElementType(ElementTyp elementTyp) {
this.elementTyp = elementTyp;
}
/**
* Testet ob die beiden Karten gleich sind
* @param card at.reisinger.obj.Card die geprüft werden soll
* @return True wenn die Karten übereinstimmen
*/
public boolean equals(Card card){
if(card == null) return false;
return this.name.equals(card.getName()) && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage();
}
}

84
src/main/java/at/reisinger/obj/Cards.java Normal file
View File

@ -0,0 +1,84 @@
package at.reisinger.obj;
import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import java.util.ArrayList;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Verwaltet eine Liste vo at.reisinger.obj.Cards
*/
@JsonAutoDetect
public class Cards {
@JsonDeserialize(as = ArrayList.class, contentAs = Card.class)
private ArrayList<Card> cards;
/**
* Erstellt ein nues obj mit gegebenen Karten
* @param cardsArrayList Die at.reisinger.obj.Cards zum erstellen des Obj
*/
@JsonCreator
public Cards(@JsonProperty("cards") ArrayList<Card> cardsArrayList) {
this.cards = cardsArrayList;
}
/**
* Setzt die Carten
* @param cards Cards in einer ArrayList die gesetzt werden sollen
*/
public void setCards(ArrayList<Card> cards) {
this.cards = cards;
}
/**
* Fügt eine neue at.reisinger.obj.Card hinzu
* @param newCard neue at.reisinger.obj.Card
*/
@JsonSetter
public void addCard(Card newCard) {
this.cards.add(newCard);
}
/**
* Holt alle at.reisinger.obj.Cards
* @return Alle at.reisinger.obj.Cards
*/
@JsonGetter
public ArrayList<Card> getCards() {
return this.cards;
}
/**
* Löscht die gegebene at.reisinger.obj.Card
* @param delCard at.reisinger.obj.Card zum löschen
*/
public void delCard(Card delCard) {
this.cards.removeIf(obj -> obj.equals(delCard));
}
/**
* Prüft ob eine at.reisinger.obj.Card in den at.reisinger.obj.Cards vorhanden ist
* @param toCeck at.reisinger.obj.Card nach der in den at.reisinger.obj.Cards gesucht werden soll
* @return True wenn die at.reisinger.obj.Card in den at.reisinger.obj.Cards ist
*/
public boolean containsCard(String toCeck){
AtomicBoolean returnval = new AtomicBoolean(false);
this.cards.forEach(item -> returnval.set(item.getName().equals(toCeck)));
return returnval.get();
}
/**
* Vergleicht 2 at.reisinger.obj.Cards Obj miteinander
* @param toCompare at.reisinger.obj.Cards zum vergleichen
* @return True wenn es aus den selben at.reisinger.obj.Cards besteht
*/
public boolean equals(Cards toCompare){
if (this.cards == null && toCompare.getCards() == null){
return true;
}else if ((this.cards == null && toCompare.getCards() != null) || (this.cards != null && toCompare.getCards() == null)){
return false;
}else return Objects.requireNonNull(this.cards).containsAll(toCompare.getCards()) && toCompare.getCards().containsAll(this.cards);
}
}

62
src/main/java/at/reisinger/obj/Coins.java Normal file
View File

@ -0,0 +1,62 @@
package at.reisinger.obj;
/**
* Alle coins eines Users
*/
public class Coins {
private int amount;
/**
* Erstellt ein neues Münzen Obj
* @param coins Alle münzen des Users
*/
public Coins(int coins) {
this.amount = coins;
}
/**
* Holt alle münzen
* @return Alle münzen
*/
public int getCoinAmount() {
return this.amount;
}
/**
* Fügt münzen hinzu
* @param coins Münzen die hinzugefügt werden -> Positiv
*/
public void addCoin(int coins){
if(coins > 0) {
this.amount += coins;
}
}
/**
* Entfernt münzen
* @param coins Münzen die entfernt werden sollen, muss positiv sein
* @return True wenn erfolgreich
*/
public boolean removeCoin(int coins){
if(coins < 0) {
return false;
}else {
this.amount -= coins;
return true;
}
}
/**
* Ändert den Absoluten Coin amount
* @param coins Neue Coin anzahl, muss positiv sein
* @return true wenn erfolgreich
*/
public boolean changeCoinAmmount(int coins){
if(coins < 0) {
return false;
}else {
this.amount = coins;
return true;
}
}
}

36
src/main/java/at/reisinger/obj/Credentials.java Normal file
View File

@ -0,0 +1,36 @@
package at.reisinger.obj;
/**
* at.reisinger.obj.User Login Daten
*/
public class Credentials {
private final String passwort;
private final String username;
/**
* Startet einen neuen at.reisinger.obj.User mit folgenden Daten
* @param username Diesem Usernamen
* @param passwort Diesem Passwort
*/
public Credentials(String username, String passwort){
this.username = username;
this.passwort = passwort;
}
/**
* Holt das Passwort des users
* @return PW des Users
*/
public String getPasswort() {
return passwort;
}
/**
* Holt den Usernamen des Users
* @return Username
*/
public String getUsername() {
return username;
}
}

54
src/main/java/at/reisinger/obj/Package.java Normal file
View File

@ -0,0 +1,54 @@
package at.reisinger.obj;
import com.fasterxml.jackson.annotation.*;
/**
* at.reisinger.obj.Package besteht aus 4 Karten. Ist eine Erweiterung der at.reisinger.obj.Cards, zeigt für 4 at.reisinger.obj.Cards den Preis und einen Packagenamen an
*/
@JsonAutoDetect
public class Package extends Cards{
@JsonProperty
private String name;
@JsonProperty
private final int price;
/**
* Erstellt ein neues at.reisinger.obj.Package mit den gegebenen Stats
* @param stack at.reisinger.obj.Cards des Packages
* @param name Name des Packages
* @param price Price des Packages
*/
@JsonCreator
public Package(@JsonProperty Cards stack,@JsonProperty String name,@JsonProperty int price) {
super(stack.getCards());
this.name = name;
this.price = price;
}
/**
* Holt den namen des Packages
* @return Name des Packages
*/
@JsonGetter
public String getName() {
return this.name;
}
/**
* Holt den Preis des Packages
* @return Preis des Packages
*/
@JsonGetter
public int getPrice() {
return this.price;
}
/**
* Setzt den Namen des Packages
* @param neuName Neuer name des Packages
*/
@JsonSetter
public void setName(String neuName) {
this.name = neuName;
}
}

158
src/main/java/at/reisinger/obj/TradingDeal.java Normal file
View File

@ -0,0 +1,158 @@
package at.reisinger.obj;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
import at.reisinger.server.helper.EnumHelper;
import com.fasterxml.jackson.annotation.*;
/**
* Ein einzelner Trading deal wird hier verwaltet.
*/
@JsonAutoDetect
public class TradingDeal {
@JsonProperty
private final String id;
@JsonProperty
private final String username;
@JsonProperty
private Card cardToTrade;
@JsonProperty
private ElementTyp requiredElementType;
@JsonProperty
private double requiredMinDamage;
@JsonProperty
private CardType requiredCardType;
/**
* Ein TradingDeal wird erstellt
* @param id Id des Trading deals
* @param cardToTrade at.reisinger.obj.Card die getauscht werden soll
* @param requiredElementType Req ElementType für den Tausch
* @param requiredMinDamage Req min damage für den Tausch
* @param requiredCardType Req at.reisinger.obj.Card Type für den Tausch
*/
public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) {
this.id = id;
this.cardToTrade = cardToTrade;
if(requiredElementType == null){
requiredElementType = ElementTyp.UNDEF;
}
if(requiredCardType == null) {
requiredCardType = CardType.UNDEF;
}
this.requiredElementType = requiredElementType;
this.requiredMinDamage = requiredMinDamage;
this.requiredCardType = requiredCardType;
this.username = username;
}
/**
* Ein TradingDeal wird erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt
* @param id Id des Trading deals
* @param cardToTrade at.reisinger.obj.Card die getauscht werden soll
* @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
* Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
*/
@JsonCreator
public TradingDeal(@JsonProperty("Id") String id, @JsonProperty("CardToTrade") Card cardToTrade, @JsonProperty("MinimumDamage") double requiredMinDamage, @JsonProperty("Type") String type, String username) {
this(id, cardToTrade, EnumHelper.stringToElementType(type), requiredMinDamage, EnumHelper.stringToCardType(type), username);
}
/**
* Holt die ID des Trading deals
* @return Id des Trading Deals
*/
public String getId() {
return id;
}
/**
* Holt den usernamen
* @return Der username als String
*/
@JsonGetter
public String getUsername() {
return username;
}
/**
* at.reisinger.obj.Card die getraded werden soll
* @return at.reisinger.obj.Card die getradet werden soll
*/
@JsonGetter
public Card getCardToTrade() {
return this.cardToTrade;
}
/**
* Req Element type holen
* @return Req Element Type
*/
@JsonGetter
public ElementTyp getRequiredElementType() {
return this.requiredElementType;
}
/**
* Req min damage holen
* @return Req min damage
*/
@JsonGetter
public double getRequiredMinDamage() {
return this.requiredMinDamage;
}
/**
* Hole req cardtype
* @return Req at.reisinger.enums.CardType
*/
@JsonGetter
public CardType getRequiredCardType() {
return this.requiredCardType;
}
/**
* Setzt die Karte die Getradet werden soll
* @param cardToTrade at.reisinger.obj.Card zum tauschen
*/
@JsonSetter
public void setCardToTrade(Card cardToTrade) {
this.cardToTrade = cardToTrade;
}
/**
* Setzt req elementType
* @param requiredElementType Der Req elementType
*/
@JsonSetter
public void setRequiredElementType(ElementTyp requiredElementType) {
this.requiredElementType = requiredElementType;
}
/**
* Setzt die req Min damage
* @param requiredMinDamage Die req min gamage
*/
@JsonSetter
public void setRequiredMinDamage(double requiredMinDamage) {
this.requiredMinDamage = requiredMinDamage;
}
/**
* Setzt req cardType
* @param requiredCardType Der Req at.reisinger.enums.CardType
*/
@JsonSetter
public void setRequiredCardType(CardType requiredCardType) {
this.requiredCardType = requiredCardType;
}
/**
* Von der at.reisinger.obj.Card im Parameter wird die at.reisinger.obj.Card mit den Requirements von THIS verglichen
* @param checkCard at.reisinger.obj.Card die mit dem Deal verglichen wird
* @return True wenn der Deal passt
*/
public boolean cardOk(Card checkCard){
return checkCard.getCardType().equals(this.requiredCardType) && (checkCard.getElementTyp().equals(this.requiredElementType) || this.requiredElementType.name().equalsIgnoreCase("undef")) && checkCard.getDamage() >= this.requiredMinDamage;
}
}

163
src/main/java/at/reisinger/obj/User.java Normal file
View File

@ -0,0 +1,163 @@
package at.reisinger.obj;
import com.fasterxml.jackson.annotation.*;
import java.util.ArrayList;
/**
* at.reisinger.obj.User & at.reisinger.Store Logik
*/
@JsonAutoDetect
public class User{
@JsonProperty
private String name, nachname, email, bio, image;
//private DBConnection db;
@JsonProperty
private final Credentials credentials;
@JsonProperty
private final Coins coins;
/*
* Erstellt einen neuen at.reisinger.obj.User
* @param credentials Zugangsdaten des Users
* @param name Name des Users
* @param nachname Nachname des Users
* @param email Email des Users
* @param stack Alle Karten des Users
* @param coins Alle Münzen des Users
@JsonCreator
public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Stack stack,@JsonProperty Coins coins) {
this.credentials = credentials;
this.name = name;
this.nachname = nachname;
this.email = email;
this.stack = stack;
this.coins = coins;
//this.db = new at.reisinger.server.DBConnection();
}
*/
@JsonCreator
public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins, @JsonProperty String bio, @JsonProperty String image) {
this.credentials = credentials;
this.name = name;
this.nachname = nachname;
this.email = email;
//this.stack = null;
this.coins = coins;
this.bio = bio;
this.image = image;
//this.db = new at.reisinger.server.DBConnection();
}
/**
* Holt die Bio vom User
* @return Bio des Users
*/
@JsonGetter
public String getBio() {
return bio;
}
/**
* Setzt die Bio vom User
* @param bio Bio des Users
*/
@JsonSetter
public void setBio(String bio) {
this.bio = bio;
}
/**
* Holt das image vom user
* @return Image vom user
*/
@JsonGetter
public String getImage() {
return image;
}
/**
* Setzt das image vom user
* @param image Image vom user
*/
@JsonSetter
public void setImage(String image) {
this.image = image;
}
/**
* Holt die eindeutigen Logindaten des Users
* @return Eindeutige Logindaten
*/
@JsonGetter
public Credentials getCredentials() {
return credentials;
}
/**
* Get Name of at.reisinger.obj.User
* @return Name of at.reisinger.obj.User
*/
@JsonGetter
public String getName() {
return this.name;
}
/**
* Get Nachname of at.reisinger.obj.User
* @return Nachname of at.reisinger.obj.User
*/
@JsonGetter
public String getNachname() {
return this.nachname;
}
/**
* Email of at.reisinger.obj.User
* @return Email of at.reisinger.obj.User
*/
@JsonGetter
public String getEmail() {
return this.email;
}
/**
* Setzt den Namen des Users
* @param name Neuer Name des Users
*/
@JsonSetter
public void setName(String name) {
this.name = name;
}
/**
* Setzt den Nachnamen
* @param nachname Neuer Nachname
*/
@JsonSetter
public void setNachname(String nachname) {
this.nachname = nachname;
}
/**
* Setzt die Email des Users
* @param email Neue Email des Users
*/
@JsonSetter
public void setEmail(String email) {
this.email = email;
}
//at.reisinger.Store Methoden
/**
* Kauft ein at.reisinger.obj.Package
* @param mypackage at.reisinger.obj.Package welches gekauft werden soll
* @return Alle Karten des neuen at.reisinger.obj.Package
*/
public ArrayList<Card> buyPackage(Package mypackage){
this.coins.removeCoin(mypackage.getPrice());
return mypackage.getCards();
}
}

792
src/main/java/at/reisinger/server/DBConnection.java Normal file
View File

@ -0,0 +1,792 @@
package at.reisinger.server;
import at.reisinger.obj.*;
import at.reisinger.obj.Package;
import at.reisinger.server.helper.JsonHelper;
import at.reisinger.server.helper.PostgresHelper;
import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
* Stellt die Verbindung zur "Datenbank" her
* Die "Datenbank" sind hier nur beispieldaten.
*/
public class DBConnection {
private Connection c;
private Statement stmt;
/**
* Erstellt alle Beispieldaten und simuliert somit den
* Verbindungsaufbau zu einer DB
*/
public DBConnection() {
this.c = null;
}
/**
* Erstellt alle Tabellen die für den Betrieb der Software bennötigt werden
*/
public void init() {
PostgresHelper.executeUpdateMessage("CREATE TABLE IF NOT EXISTS USERS (username TEXT PRIMARY KEY NOT NULL, nachname TEXT NOT NULL, email TEXT NOT NULL, password TEXT NOT NULL, bio TEXT, image TEXT, coins integer default 20 not null)", "User Table created");
PostgresHelper.executeUpdate("CREATE TABLE IF NOT EXISTS CARD(NAME TEXT not null,DAMAGE FLOAT not null,ELEMENTTYP TEXT not null,CARDTYPE TEXT not null, PRIMARY KEY (\"name\"));");
PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);", "Card Table created");
PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS package(\"ID\" varchar(255) not null,name varchar(255) not null constraint name references card, i serial not null constraint package_i primary key );", "Package Table created");
PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_cards(username TEXT not null constraint user_cards_users_username_fk references users,name text not null, gesperrt boolean not null);", "UserCards Table created");
PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_deck(username text not null constraint user_deck_users_username_fk references users,cardname text not null);", "UserDeck Table created");
PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS trading(username text not null constraint trading_users_username_fk references users,id text not null constraint trading_pk primary key, cardtotrade text not null constraint trading_card_name_fk references card, mindamage float not null,reqcardtype text not null,reqelement text not null);", "Trading Table created");
PostgresHelper.executeUpdate("create table if not exists battle(usernamecreator text not null constraint battle_users_username_fk references users,usernameplayer text constraint battle_users_username_fk_2 references users, battleid serial, deckcreator text not null);");
PostgresHelper.executeUpdateMessage("create unique index if not exists battle_battleid_uindex on battle (battleid);", "Battle Table created");
PostgresHelper.executeUpdate("create table IF NOT EXISTS battle_log(id int not null constraint battle_log_pk primary key, playerone text not null,playertwo text not null,playeronescore text not null,playertwoscore text not null,log varchar(10485760));");
PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS battle_log_id_uindex on battle_log (id);", "Battle_lgo Table created");
}
/**
* Holt alle BattleIds an denen der User beteiligt war
* @param username User der zu prüfen ist
* @return Null bei fehler, sonst eine List aus den IDs
*/
public ArrayList<String> getAllBattleIdUser(String username){
this.c = PostgresHelper.con();
int id;
ArrayList<String> battleIds = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select id from battle_log where playerone = '" + username + "' or playertwo = '" + username + "';");
while (rs.next()) {
id = rs.getInt("id");
if (id > 0) {
System.out.println("BATTLE ID: " + id);
battleIds.add(id + "");
}else {
return null;
}
}
rs.close();
stmt.close();
this.c.close();
return battleIds;
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
}
/**
* Holt die Letzte BattleId eines users
* @param username Userid die geprüft werden soll
* @return -1 bei error, sonst die letzte battleid des users
*/
public int getLastBattleIdUser(String username){
this.c = PostgresHelper.con();
int id;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select max(id) from battle_log where playerone = '" + username + "' or playertwo = '" + username + "';");
while (rs.next()) {
id = rs.getInt("max");
System.out.println("select max(id) from battle_log where playerone = '" + username + "' or playerone = '" + username + "';");
System.out.println("PREEEE IF ID: " + id);
if (id > 0) {
System.out.println("LAST BATTLE ID: " + id);
return id;
}else {
return -1;
}
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return -1;
}
return -1;
}
/**
* Holt das Battellog eines Bestimmten Battles
* @param battleId Id des battles
* @return Eine Map mit namen von player1 und player2, player1Score und player2Score und log
*/
public Map<String, String> getBattleLog(String battleId){
this.c = PostgresHelper.con();
String playerone, playertwo, score1, score2, log;
int id;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from battle_log where id = " + battleId + ";");
while (rs.next()) {
id = rs.getInt("id");
playerone = rs.getString("playerone");
playertwo = rs.getString("playertwo");
score1 = rs.getString("playeronescore");
score2 = rs.getString("playertwoscore");
log = rs.getString("log");
if (id > 0 && !playerone.isEmpty() && !playertwo.isEmpty() && !score1.isEmpty() && !score2.isEmpty() && !log.isEmpty()){
Map<String, String> map = new java.util.HashMap<>(Collections.emptyMap());
map.put("playerone", playerone);
map.put("playertwo", playertwo);
map.put("playeronescore", score1);
map.put("playertwoscore", score2);
map.put("log", log);
map.put("id", id+"");
return map;
}else{
System.out.println("GET BATTLE LOG WAS EMPTY");
return null;
}
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
return null;
}
/**
* Fügt der Battle tabelle ein battle hinzu
* @return True bei erfolg, sonst false
*/
public boolean addBattle(String usernamecreator){
ArrayList<String> decknamen = getDeck(usernamecreator);
if(decknamen != null && !decknamen.isEmpty()){
Cards deck = getCardsFromIDList(decknamen);
if(deck != null && !deck.getCards().isEmpty()){
String deckJson = JsonHelper.objToJson(deck.getCards());
if (deckJson != null && !deckJson.isEmpty()){
return PostgresHelper.executeUpdateMessage("insert into battle (usernamecreator, deckcreator) VALUES ('" + usernamecreator + "','" + deckJson + "');", "Battle created");
}else {
return false;
}
}else {
return false;
}
}else{
return false;
}
}
/**
* Sucht ein verfügbares open battle aus der DB und löscht gleichzeitig das open battle
* @return Null falls keines verfügbar ist oder ein erir auftritt
*/
public Battle getOpenBattle(){
this.c = PostgresHelper.con();
int battleid;
String usernamecreator;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from battle limit 1;");
while (rs.next()) {
battleid = rs.getInt("battleid");
usernamecreator = rs.getString("usernamecreator");
User player1 = new DBConnection().getUser(usernamecreator);
if(player1 != null){
ArrayList<String> deckPlayer1Arr = new DBConnection().getDeck(usernamecreator);
if (deckPlayer1Arr != null){
Cards deckPlayer1 = new DBConnection().getCardsFromIDList(deckPlayer1Arr);
if(deckPlayer1 != null){
if(delBattleEinladung(battleid+"")){
return new Battle(battleid, player1, deckPlayer1);
}else{
return null;
}
}else{
return null;
}
}else {
return null;
}
}else{
return null;
}
}
rs.close();
stmt.close();
this.c.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
return null;
}
return null;
}
/**
* Löscht die Battle einladung eines einzelnen spielers
* @param battleid Id die zu löschen ist
* @return true bei erfolg sonst false
*/
public boolean delBattleEinladung(String battleid){
return PostgresHelper.executeUpdateMessage("delete from battle where battleid = '" + battleid + "';", "Battle req deleted");
}
/**
* Nach einem Battle wird das log eingefügt, dabei wird die selbe id wie beim battle verwendet
* @param id Id des Battles
* @param playerone Name vom Player 1
* @param playertwo Name vom Player 2
* @param playeronescore Score vom Player 1
* @param playertwoscore Score vom Player 2
* @return true bei erfolg sonst false
*/
public boolean addBattleLog(String id, String playerone, String playertwo, String playeronescore, String playertwoscore, String log){
return PostgresHelper.executeUpdate("insert into battle_log (id, playerone, playertwo, playeronescore, playertwoscore, log) VALUES ("+id+ ",'" +playerone+ "','" +playertwo+ "','" +playeronescore+ "','" +playertwoscore+ "','" +log+ "');");
}
/**
* Updated den Lock einer user card
* @param name Name der Card
* @param lock Zustand des Locks
* @return true bei erfolg, sonst false
*/
public boolean updateCardLock(String name, boolean lock){
return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = '" + name + "';");
}
/**
* Prüft ob eine Card für das Deck gesperrt ist
* @param name Name der Card die zu prüfen ist
* @return True falls gesperrt, ansonst false
* @throws SQLException Locked Cards konnten nicht aus der DB geholt werden
*/
public boolean getCardLock(String name) throws SQLException {
this.c = PostgresHelper.con();
boolean locked = false;
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select gesperrt from user_cards where name = '" + name + "';");
while (rs.next()) {
locked = rs.getBoolean("gesperrt");
}
rs.close();
stmt.close();
this.c.close();
return locked;
}
/**
* Löscht einen Trading Deal aus der Datenbank
* @param id Id des deals der gelöscht werden soll
* @return True bei erfolg, sonst false
*/
public boolean deleteTradingDeal(String id){
return PostgresHelper.executeUpdate("delete from trading where id = '" + id + "';");
}
/**
* Fügt der DB einen Trading deal hinzu
* @param username User der den Trade hinzufügt
* @param id Id des Trades
* @param mindamage Min damage der für den trade benötigt wird
* @param reqcardtype Req Card Type der für den trade benötigt wird
* @param reqelement Req Element Typ der für den trade benötigt wird
* @param cardtotrade Card die zum Traden ist
* @return True bei erfolg, sonst false
*/
public boolean addTradingdeal(String username, String id, double mindamage, String reqcardtype, String reqelement, String cardtotrade){
return PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES ('" + username + "','" + id + "','" + cardtotrade + "','" + mindamage + "','" + reqcardtype + "','" + reqelement + "');");
}
/**
* Holt alle Trading Deals aus der DB
* @return Null bei error
*/
public ArrayList<TradingDeal> getAllTradingDeals(){
this.c = PostgresHelper.con();
ArrayList<TradingDeal> tradingDeals = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from trading;");
while (rs.next()) {
String username, id, cardtotrade, reqcardtype, reqelement;
int mindamage;
username = rs.getString("username");
id = rs.getString("id");
cardtotrade = rs.getString("cardtotrade");
reqcardtype = rs.getString("reqcardtype");
reqelement = rs.getString("reqelement");
mindamage = rs.getInt("mindamage");
Card card = new DBConnection().getCardFromID(cardtotrade);
if(card != null){
TradingDeal tmp = new TradingDeal(id, card, mindamage, reqcardtype +reqelement, username);
tradingDeals.add(tmp);
}else{
return null;
}
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
return tradingDeals;
}
/**
* Setzt das Deck eines Users
* @param username Username von dem das Deck gesetzt werden soll
* @param deck Die ID´s des Decks in der Form einer ArrayList<String>
* @return True bei erfolg, sonst false
*/
public boolean setDeck(String username, List<String> deck){
for (String st :deck) {
try {
if(getCardLock(st)){
return false;
}
} catch (SQLException throwables) {
throwables.printStackTrace();
return false;
}
}
Cards allCards = getCards(username);
Cards deckCards = new Cards(new ArrayList<>());
int count = 0;
if(allCards != null && deck.size() == 4){
for (String st : deck) {
for (Card ca: allCards.getCards()) {
if(ca.getName().equals(st) && count < 4){
if(deckCards.getCards().size() == 0){
if (!delDeck(username)){
return false;
}
}
deckCards.addCard(ca);
if(deckCards.getCards().size() == 4){
int c = 0;
for(Card cardtmp : deckCards.getCards()){
c++;
if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES ('" +username+ "', '" +cardtmp.getName()+ "');", "Card #"+c+" added to Deck")){
return false;
}
}
return true;
}
}
}
count++;
}
return false;
}
return false;
}
/**
* Holt alle Card namen aus dem Deck eines Users
* @param username user von dem die Deck namen geholt werden soll
* @return null bedeuted error
*/
public ArrayList<String> getDeck(String username){
this.c = PostgresHelper.con();
String cardname;
ArrayList<String> cardnamenarray = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from user_deck where username = '" + username + "';");
while (rs.next()) {
cardname = rs.getString("cardname");
cardnamenarray.add(cardname);
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
return cardnamenarray;
}
/**
* Löscht den gesammten inhalt des Decks eines users
* @param username Username von dem das Deck gelöscht werden soll
* @return True bei erfolg, sonst false
*/
public boolean delDeck(String username){
return PostgresHelper.executeUpdateMessage("delete from user_deck where username = '" + username + "';", "User Deck: " + username + ", deleted");
}
/**
* Holt ein Random package aus dem Shop
*
* @param username User der das Package haben möchte
* @return Das Package aus dem Shop, null falls ein Fehler auftritt
*/
public Package userAcquirePackage(String username) {
int coins = checkCoins(username);
if (!(coins - 5 >= 0)) {
return null;
}
if(!updateCoins(coins - 5, username)){
return null;
}
this.c = PostgresHelper.con();
String id = "";
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select \"ID\" as id from package LIMIT 1;");
while (rs.next()) {
id = rs.getString("id");
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
this.c = PostgresHelper.con();
String packagename = "", cardname, elementtyp, cardtype;
int damage;
Cards cards = new Cards(new ArrayList<>());
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select i as zeilennummer, package.\"ID\" as id, package.name as packagename, c.name as cardname, c.DAMAGE as damage, c.ELEMENTTYP as elementtyp, c.CARDTYPE as cardtype from package join card c on c.name = package.name where \"ID\" = '" + id + "';");
while (rs.next()) {
id = rs.getString("id");
packagename = rs.getString("packagename");
cardname = rs.getString("cardname");
elementtyp = rs.getString("elementtyp");
cardtype = rs.getString("cardtype");
damage = rs.getInt("damage");
Card newCard = new Card(cardname, elementtyp + cardtype, damage);
cards.addCard(newCard);
if(!addUserCard(username, newCard.getName())){
return null;
}
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
if(!deletePackage(id)){
return null;
}
if (cards.getCards().size() != 0) {
return new at.reisinger.obj.Package(cards, packagename, 5);
} else {
return null;
}
}
/**
* Löscht eine user card aus der DB
* @param username Card löschen von
* @param cardname Card die vom user zu löschen ist
* @return True bei erfolg, sonst false
*/
public boolean delUserCard(String username, String cardname){
return PostgresHelper.executeUpdate("delete from user_cards where username = '" +username+ "' and name = '" +cardname+ "';");
}
/**
* Fügt eine Card zu den User_Cards hinzu
* @param username Username der die Card bekommt
* @param cardName Card die der User bekommt
* @return True bei erfolg, sonst false
*/
public boolean addUserCard(String username, String cardName){
Connection b = PostgresHelper.con();
try {
stmt = b.createStatement();
String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( '" + username + "','" + cardName + "', 'false');";
stmt.executeUpdate(sql);
stmt.close();
b.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return false;
}
return true;
}
/**
* Löscht ein Package anhand des Namens
*
* @param name Name des Packages das gelöscht werden soll
* @return True bei erfolg, sonst false
*/
public boolean deletePackage(String name) {
return PostgresHelper.executeUpdateMessage("DELETE FROM package WHERE \"ID\" = '" + name + "';", "Package deleted successfully");
}
/**
* Coins setzten
*
* @param coins Anzahl die zu setzten ist
* @return True bei erfolg, sonst false
*/
public boolean updateCoins(int coins, String username) {
return PostgresHelper.executeUpdateMessage("UPDATE users SET coins = " + coins + " WHERE username = '" + username + "';", "Coins Updated");
}
/**
* Gibt die Anzahl an verfügbaren coins zurück
*
* @return Anzahl der Coins, -1 ist error
*/
public int checkCoins(String username) {
this.c = PostgresHelper.con();
int coins = 0;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("Select coins from users where username = '" + username + "';");
while (rs.next()) {
coins = rs.getInt("coins");
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return -1;
}
return coins;
}
/**
* Überprüft anhand des Namen der Karte, ob es schon eine solche Karte gibt
*
* @param name Name der zu prüfen ist
* @return True falls die Karte bereits existiert
*/
public boolean cardExists(String name) {
this.c = PostgresHelper.con();
int count = 0;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select count(*) from card where name = '" + name + "';");
while (rs.next()) {
count = rs.getInt("count");
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
System.exit(0);
}
return count == 1;
}
/**
* Fügt eine Karte der DB hinzu
*
* @param card Card die hinzugefügt werden soll
* @return true bei erfolg, false bei error
*/
public boolean addCard(Card card) {
return PostgresHelper.executeUpdateMessage("insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values ('" + card.getName() + "','" + card.getDamage() + "','" + card.getElementTyp().name() + "','" + card.getCardType().name() + "')", "Card added");
}
/**
* Ermittelt die nächste Package ID
*
* @return Die Nächste Package id, wenn 0, dann ist ein error
*/
public int nextPackageId() {
this.c = PostgresHelper.con();
String id = "";
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select max(\"ID\") from package;");
while (rs.next()) {
id = rs.getString("max");
}
if (id == null) {
id = "0";
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return 0;
}
return Integer.parseInt(id) + 1;
}
/**
* Fügt eine Package der DB hinzu,
* wenn eine Karte aus dem Package noch nicht in der Db ist,
* dann wird es automatisch hinzugefuegt
*
* @param pack Pack welches hinzugefügt werden soll
* @return True bei erfolg, false bei fehler
*/
public boolean addPackage(at.reisinger.obj.Package pack) {
for (Card ca : pack.getCards()) {
if (!cardExists(ca.getName())) {
if (!addCard(ca)) {
return false;
}
}
if(!PostgresHelper.executeUpdateMessage("INSERT INTO package (\"ID\", \"name\") values ('" + pack.getName() + "','" + ca.getName() + "');", "Card zu Package hinzugefügt")){
return false;
}
}
return true;
}
/**
* Fügt einen User der DB hinzu
*
* @param username Username des Users
* @param password Passwort des Users
* @param nachname nachname des Users
* @param email Email des Users
* @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war
*/
public boolean addUser(String username, String password, String nachname, String email, String bio, String image) {
return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password, bio, image) values ('" + username + "','" + nachname + "','" + email + "','" + password + "','" + bio + "','" + image + "')", "User added");
}
/**
* Updated den Nachnamen, Bio und das Image eines Users mit gegebenen usernamen
* @param username User der geändert werden soll
* @param bio Neue BIO
* @param image Neues Image
* @param name Neuer Nachname
* @return True bei erfolg, sonst false
*/
public boolean updateUser(String username, String bio, String image, String name){
return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = '" + name+ "', bio = '" +bio+ "', image = '" +image+ "' WHERE username LIKE '" +username+ "' ESCAPE '#'");
}
/**
* Sucht einen User anhand des Usernamens.
* Gibt ein User Objekt zurück
*
* @param uname Username der zu suchen ist
* @return User als User Objekt, null bei fehler
*/
public User getUser(String uname){
this.c = PostgresHelper.con();
String username = "", password = "", email = "", bio="", image="";
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users where username = '" + uname + "';");
while (rs.next()) {
username = rs.getString("username");
email = rs.getString("email");
password = rs.getString("password");
bio = rs.getString("bio");
image = rs.getString("image");
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
return new User(new Credentials(username, password), username, username, email, new Coins(20), bio, image);
}
/**
* Holt eine Card aus der DB, anhand der gegebenen Card Id
* @param id Id der Card die geholt werden soll
* @return Null bei error
*/
public Card getCardFromID(String id){
Connection b = PostgresHelper.con();
Card toreturn = null;
try {
stmt = b.createStatement();
ResultSet rs = stmt.executeQuery("select * from card where NAME = '" + id + "';");
while (rs.next()) {
int damage =rs.getInt("damage");
String elementtyp =rs.getString("elementtyp");
String cardtype=rs.getString("cardtype");
toreturn = new Card(id, elementtyp+cardtype, damage);
}
rs.close();
stmt.close();
b.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
return toreturn;
}
/**
* Holt alle Carten einer gegebenen Card ID List
* @param cardnamenarray Card IDs in einer Liste
* @return Falls null, dann war ein error
*/
public Cards getCardsFromIDList(List<String> cardnamenarray){
Cards allCards = new Cards(new ArrayList<>());
for (String st : cardnamenarray) {
Connection b = PostgresHelper.con();
try {
stmt = b.createStatement();
ResultSet rs = stmt.executeQuery("select * from card where NAME = '" + st + "';");
while (rs.next()) {
int damage =rs.getInt("damage");
String elementtyp =rs.getString("elementtyp");
String cardtype=rs.getString("cardtype");
allCards.addCard(new Card(st, elementtyp+cardtype, damage));
}
rs.close();
stmt.close();
b.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
}
return allCards;
}
/**
* Holt alle Karten eines Users
* @param username Username des Users
* @return Cards Object, falls es null ist, war ein fehler
*/
public Cards getCards(String username){
this.c = PostgresHelper.con();
String cardname;
ArrayList<String> cardnamenarray = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from user_cards where username = '" + username + "';");
while (rs.next()) {
cardname = rs.getString("name");
cardnamenarray.add(cardname);
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
return getCardsFromIDList(cardnamenarray);
}
}

59
src/main/java/at/reisinger/server/Main.java Normal file
View File

@ -0,0 +1,59 @@
package at.reisinger.server;
import at.reisinger.server.objects.Request;
import at.reisinger.server.objects.Response;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* Grundlegende Server logic
* Vereint alle anderen Klassen
*/
public class Main {
static final int port = 80;
private Socket socket;
/**
* Initial Start
* @param args Nicht Verwendet
*/
public static void main(String[] args) {
new DBConnection().init();
System.out.println("\n\nStarte Server auf Port " + port + "\n\n");
new Main(port);
}
/**
* Öffnet den Server Socket und akzepiert diesen
* @param port Port auf dem der Server läuft
*/
public Main(int port){
ServerSocket serverSocket;
try {
serverSocket = new ServerSocket(port);
while (true){
this.socket = serverSocket.accept();
requestResponding();
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Jeder Request durchläuft diese Funktion, reagiert auf requests
*/
public void requestResponding(){
try{
System.out.println("Socket wurde gestartet!");
Request rq = new Request(this.socket);
new Response(rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload());
this.socket.close();
System.out.println("Socket wurde geschlossen!");
}catch (IOException e){
e.printStackTrace();
}
}
}

38
src/main/java/at/reisinger/server/helper/EnumHelper.java Normal file
View File

@ -0,0 +1,38 @@
package at.reisinger.server.helper;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
/**
* Hilft beim manipulieren von enums
*/
public class EnumHelper {
/**
* Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück
* @param elementTypeString elementType als String
* @return Passender Element Type oder null falls nicht gefunden
*/
public static ElementTyp stringToElementType(String elementTypeString){
for (ElementTyp e : ElementTyp.values()) {
if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) {
return e;
}
}
return null;
}
/**
* Wenn ein String als cardType vorhanden ist, dann gibt er den passenden cardType zurück
* @param cardTypeString cardType als String
* @return Passender Card Type oder null falls nicht gefunden
*/
public static CardType stringToCardType(String cardTypeString){
for (CardType me : CardType.values()) {
if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
return me;
}
}
return null;
}
}

77
src/main/java/at/reisinger/server/helper/JsonHelper.java Normal file
View File

@ -0,0 +1,77 @@
package at.reisinger.server.helper;
import at.reisinger.obj.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import java.util.Map;
/**
* Hilfsfunktionen für Jackson Json
*/
public class JsonHelper {
/**
* Wandelt ein Objekt in ein Json um
* @param obj Objekt das in ein Json umgewandelt werden soll
* @return Json String des Packages
*/
public static String objToJson(Object obj){
ObjectMapper objectMapper = new ObjectMapper();
String packageJson = "";
if(obj != null) {
try {
packageJson += objectMapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
packageJson = "Error: JsonProcessingException -> " + e.getMessage();
}
return packageJson;
}else{
return null;
}
}
/**
* Json zu List
* @param payload Json String
* @return List aus dem json, bei einer JsonProcessingException null
*/
public static List<String> jsonPayloadToList(String payload){
ObjectMapper objectMapper = new ObjectMapper();
try {
return objectMapper.readValue(payload, new TypeReference<>() {
});
} catch (JsonProcessingException e) {
e.printStackTrace();
return null;
}
}
/**
* Json zu Map
* @param payload Json String
* @return Map aus dem json, bei einer JsonProcessingException null
*/
public static Map<String, Object> jsonPayloadToMap(String payload){
ObjectMapper objectMapper = new ObjectMapper();
try {
return objectMapper.readValue(payload, new TypeReference<>() {
});
} catch (JsonProcessingException e) {
e.printStackTrace();
return null;
}
}
/**
* Wandelt ein Objekt in ein Json um
* @param user Objekt das in ein Json umgewandelt werden soll
* @return Json String des Packages
*/
public static String userToJson(User user){
return objToJson(user);
}
}

59
src/main/java/at/reisinger/server/helper/PostgresHelper.java Normal file
View File

@ -0,0 +1,59 @@
package at.reisinger.server.helper;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
/**
* Hilfsfunktionen für die verwendung der Postgres DB
*/
public class PostgresHelper {
/**
* Verbindet mit der Datenbank
* @return Das Connection Objekt
*/
public static Connection con() {
Connection c = null;
try {
Class.forName("org.postgresql.Driver");
c = DriverManager
.getConnection("jdbc:postgresql://postgres.dergeorg.at:5432/mtcg",
"user", "user");
} catch (Exception e) {
e.printStackTrace();
System.err.println(e.getClass().getName() + ": " + e.getMessage());
}
return c;
}
/**
* Führt ein Sql statement ohne rückgabe aus, mit message nachricht
* @param sql Sql command
* @return True bei erfolg, sonst false
*/
public static boolean executeUpdateMessage(String sql, String message){
System.out.println(message);
return executeUpdate(sql);
}
/**
* Führt ein Sql statement ohne rückgabe aus
* @param sql Sql command
* @return True bei erfolg, sonst false
*/
public static boolean executeUpdate(String sql){
Connection c = con();
Statement stmt;
try {
stmt = c.createStatement();
stmt.executeUpdate(sql);
stmt.close();
c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return false;
}
return true;
}
}

23
src/main/java/at/reisinger/server/helper/ResponseHelper.java Normal file
View File

@ -0,0 +1,23 @@
package at.reisinger.server.helper;
/**
* Einige helper Funktionen der Respone Class
*/
public class ResponseHelper {
public static StringBuilder logLineBreak(String log){
StringBuilder resString = new StringBuilder();
for (char lo: log.toCharArray()){
if(lo == ','){
resString.append("\n");
}else if(lo == '['){
resString.append("\n");
}else if(lo == ']'){
resString.append("\n");
}else {
resString.append(lo);
}
}
return resString;
}
}

123
src/main/java/at/reisinger/server/objects/Request.java Normal file
View File

@ -0,0 +1,123 @@
package at.reisinger.server.objects;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Verarbeitet einen Request
* @author Georg Reisinger
*/
public class Request {
private final PrintStream out;
private final String cmd;
private final String url;
private final String payload;
private final String authString;
/**
* Besorgt alle nötigen infos aus dem request
* @param socket Socket von dem der Request kommt
*/
public Request(Socket socket) throws IOException {
StringBuilder rqBuilder = new StringBuilder();
this.out = new PrintStream(socket.getOutputStream());
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line = bufferedReader.readLine();
while (!line.isBlank()) {
rqBuilder.append(line).append("\r\n");
line = bufferedReader.readLine();
System.out.println(line);
}
String request = rqBuilder.toString();
String[] requestsLines = request.split("\r\n");
String[] requestLine = requestsLines[0].split(" ");
String method = requestLine[0];
String path = requestLine[1];
String version = requestLine[2];
String host = requestsLines[1].split(" ")[1];
//code to read the post payload data
StringBuilder payload = new StringBuilder();
while(bufferedReader.ready()){
payload.append((char) bufferedReader.read());
}
System.out.println("Payload: " + payload.toString());
this.payload = payload.toString();
this.url = path;
this.cmd = method;
List<String> headers = new ArrayList<>(Arrays.asList(requestsLines).subList(2, requestsLines.length));
String accessLog = String.format("Client %s, method %s, path %s, version %s, host %s, headers %s",
socket.toString(), method, path, version, host, headers.toString());
System.out.println(accessLog);
if(headers.toString().contains("Authorization: Basic")) {
int authIndex = headers.toString().indexOf("Authorization: Basic");
String authString = headers.toString().substring(authIndex + 21);
int authIndexEnd = authString.indexOf(',');
if(authIndexEnd == -1){
authIndexEnd = authString.indexOf(']');
}
authString = authString.substring(0, authIndexEnd);
this.authString = authString;
}else{
this.authString = null;
}
}
/**
* Auth Header
* @return get Auth Header
*/
public String getAuthString() {
return authString;
}
/**
* Get PrintStream --> Output
*
* @return out PrintStream --> Output
*/
public PrintStream getOut() {
return this.out;
}
/**
* Command wie GET, PUT, POST, DEL
*
* @return cmd als String
*/
public String getCmd() {
return this.cmd;
}
/**
* Request url
*
* @return url als String
*/
public String getUrl() {
return this.url;
}
/**
* Payload des Request
*
* @return payload als String
*/
public String getPayload() {
return this.payload;
}
}

602
src/main/java/at/reisinger/server/objects/Response.java Normal file
View File

@ -0,0 +1,602 @@
package at.reisinger.server.objects;
import at.reisinger.obj.*;
import at.reisinger.obj.Package;
import at.reisinger.server.DBConnection;
import at.reisinger.server.helper.JsonHelper;
import at.reisinger.server.helper.ResponseHelper;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.PrintStream;
import java.util.*;
/**
* Erstellt und sendet eine Response anhand des Requests
* @author Georg Reisinger
*/
public class Response {
private final PrintStream out;
private final String url;
private final String payload;
private final String authString;
/**
* Nimmt die Daten des requests und generiert eine Response
* @param url Request Url
* @param cmd Request CMD
* @param out out Print Stream
* @param authString Der MsgHandler
* @param payload Payload des Requests
*/
public Response(String url, String cmd, PrintStream out, String authString, String payload){
this.authString = authString;
this.url = url;
this.out = out;
this.payload = payload;
if (this.url != null) {
switch (cmd) {
case "GET":
if (login()) {
getMethodes();
} else {
sendResponse("Login Error", "401");
}
break;
case "POST":
try {
postMethodes();
} catch (JsonProcessingException e) {
e.printStackTrace();
}
break;
case "PUT":
if (login()) {
putMethodes();
} else {
sendResponse("Login Error", "401");
}
break;
case "DELETE":
if (login()) {
deleteMethodes();
} else {
sendResponse("Login Error", "401");
}
break;
default:
sendResponse("", "405");
break;
}
}
}
/**
* Alle Get Methoden
* Nur für angemeldete user erreichbar
*/
private void getMethodes(){
if (this.url.startsWith("/users")) {
String username = this.url.substring(this.url.lastIndexOf('/') + 1);
User user;
user = new DBConnection().getUser(username);
if (user != null){
String userJson = JsonHelper.userToJson(user);
if(userJson != null && !userJson.isEmpty()){
sendResponse(userJson, "200");
}
}else{
sendResponse("", "500");
}
} else if (this.url.startsWith("/cards")) {
String username = basicAuthGetUsername(this.authString);
Cards allCards = new DBConnection().getCards(username);
String jsonCards = JsonHelper.objToJson(allCards);
if (jsonCards != null && !jsonCards.isEmpty()){
sendResponse(jsonCards, "200");
}else{
sendResponse("", "500");
}
}else if(this.url.startsWith("/deck")) {
String format = this.url.substring(this.url.lastIndexOf('?') + 1);
String username = basicAuthGetUsername(this.authString);
ArrayList<String> allCards = new DBConnection().getDeck(username);
Cards deck;
Object tmp;
if(format.startsWith("format=plain")){
tmp = allCards;
}else{
deck = new DBConnection().getCardsFromIDList(allCards);
tmp = deck;
}
String jsonCards = JsonHelper.objToJson(tmp);
if (jsonCards != null && !jsonCards.isEmpty()) {
sendResponse(jsonCards, "200");
} else {
sendResponse("", "500");
}
}else if(this.url.startsWith("/tradings")) {
ArrayList<TradingDeal> allDeals = new DBConnection().getAllTradingDeals();
if(allDeals != null && !allDeals.isEmpty()){
String json = JsonHelper.objToJson(allDeals);
if(json != null && !json.equals("")){
sendResponse(json, "200");
}else{
sendResponse("", "500");
}
}else{
sendResponse("", "500");
}
}else if(this.url.startsWith("/score")) {
String username = basicAuthGetUsername(this.authString);
if (username != null && !username.isEmpty()){
int lastBallteId = new DBConnection().getLastBattleIdUser(username);
if (lastBallteId > -1){
Map<String, String> map = new DBConnection().getBattleLog(lastBallteId + "");
if(map != null && !map.isEmpty()){
sendResponse("BATTLE #" + map.get("id") + "\nSCORE\n" + map.get("playerone") + "(#Player1) |vs| " + map.get("playertwo") + "(#Player2) \n" + map.get("playeronescore") + "(#Player1) |vs| " + map.get("playertwoscore") + "(#Player2) \nGame LOG:\n" + ResponseHelper.logLineBreak(map.get("log")), "200");
}else {
sendResponse("Konnte Battle log nicht holen", "500");
}
}else {
sendResponse("Last Battle ID error", "500");
}
}else{
sendResponse("Login Error", "401");
}
}else if(this.url.startsWith("/stats")) {
String username = basicAuthGetUsername(this.authString);
if (username != null && !username.isEmpty()) {
ArrayList<String> battleIds = new DBConnection().getAllBattleIdUser(username);
if (battleIds != null && !battleIds.isEmpty()){
StringBuilder resString = new StringBuilder();
for(String i : battleIds){
Map<String, String> map = new DBConnection().getBattleLog(i + "");
if(map != null && !map.isEmpty()){
resString = new StringBuilder("BATTLE #" + map.get("id") + "\nSCORE\n" + map.get("playerone") + "(#Player1) |vs| " + map.get("playertwo") + "(#Player2) \n" + map.get("playeronescore") + "(#Player1) |vs| " + map.get("playertwoscore") + "(#Player2) \nGame LOG:\n");
resString.append(ResponseHelper.logLineBreak(map.get("log")));
}else {
sendResponse("Konnte Battle log nicht holen", "500");
}
}
sendResponse(resString.toString(), "200");
}else {
sendResponse("Konnte Battle ids ned holen", "500");
}
}else{
sendResponse("Login Error", "401");
}
}else{
sendResponse("", "204");
}
}
/**
* Vergleicht das angegebene PW mit dem gespeicherten PW, True wenn richtig
* @param username User aus DB
* @param password PW zu User aus DB
* @param compareTo Base64 String von Basic Auth
* @return True if Login is correct, false if incorrect
*/
private boolean basicAuth(String username, String password, String compareTo){
String authStringEnc = basicAuthBase64(username, password);
return compareTo.equals(authStringEnc);
}
/**
* Erstellt den basicAuth Base64 Token aus Username und Passwort
* @param username Username für den Token
* @param password Passwort für den Token
* @return Der Base64 BasicAtuth String
*/
private String basicAuthBase64(String username, String password){
String authString = username + ":" + password;
byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes());
return new String(authEncBytes);
}
/**
* Aus dem Base64 BasicAuth String wird der Username extrahiert
* @param authString Base64 BasicAuth String aus dem der Username ausgelesen werden soll
* @return Der Username der in dem Base64 BasicAuth String ist
*/
private String basicAuthGetUsername(String authString) {
String[] values;
if (authString != null) {
byte[] credDecoded = Base64.getDecoder().decode(authString);
String credentials = new String(credDecoded);
values = credentials.split(":", 2);
}else{
values = null;
}
return Objects.requireNonNull(values)[0];
}
/**
* Alle Post Methoden, siehe API beschreibung für genauere details
*
* Kann auch von nicht angemeldeten usern erreicht werden.
* login() wird hier verwendet
* @throws JsonProcessingException Fehler beim de-/serialisieren
*/
private void postMethodes() throws JsonProcessingException {
if (this.url.startsWith("/users")) {
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String username = (String) Objects.requireNonNull(map).get("Username");
String password = (String) map.get("Password");
User newUser = new User(new Credentials(username, password), username, username, "not implemented", new Coins(20), "BIO", "IMAGE");
DBConnection con = new DBConnection();
if(!con.addUser(newUser.getCredentials().getUsername(), newUser.getCredentials().getPasswort(), newUser.getCredentials().getUsername(), newUser.getEmail(), newUser.getBio(), newUser.getImage())){
sendResponse("", "409");
}
String userJson = JsonHelper.userToJson(newUser);
if(userJson != null) {
sendResponse(userJson, "201");
}else{
sendResponse("", "500");
}
}else if (this.url.startsWith("/sessions")) {
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String username = (String) Objects.requireNonNull(map).get("Username");
String password = (String) map.get("Password");
User user;
DBConnection con = new DBConnection();
user = con.getUser(username);
String authString = basicAuthBase64(user.getCredentials().getUsername(), user.getCredentials().getPasswort());
if(basicAuth(username, password, authString)){
sendResponse(authString, "200");
}else{
sendResponse("Login Error", "401");
}
}else if (this.url.startsWith("/packages")) {
if (basicAuth("admin", "istrator", this.authString)) {
ObjectMapper objectMapper = new ObjectMapper();
ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<>() {
});
Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5);
if (!new DBConnection().addPackage(packageCards)) {
sendResponse("", "500");
} else {
String packageJson = JsonHelper.objToJson(packageCards);
if (packageJson != null) {
sendResponse(packageJson, "201");
} else {
sendResponse("", "500");
}
}
} else {
sendResponse("Login Error", "401");
}
}else if (this.url.startsWith("/transactions/packages")) {
if (login()) {
DBConnection db = new DBConnection();
Package newPackage = db.userAcquirePackage(basicAuthGetUsername(this.authString));
if (newPackage == null) {
sendResponse("", "500");
} else {
String packageJson = JsonHelper.objToJson(newPackage);
if (packageJson == null) {
sendResponse("", "500");
} else {
sendResponse(packageJson, "200");
}
}
}else{
sendResponse("Login Error", "401");
}
}else if (this.url.startsWith("/tradings")) {
if(login()) {
String dotradeid = this.url.substring(this.url.lastIndexOf('/') + 1);
if (!dotradeid.isEmpty() && !dotradeid.equals("tradings")) {
//DO TRADE
String username = basicAuthGetUsername(this.authString);
if (username != null && !username.isEmpty()) {
ArrayList<TradingDeal> tradingDealArrayList = new DBConnection().getAllTradingDeals();
TradingDeal tradingDeal = null;
if (tradingDealArrayList != null && !tradingDealArrayList.isEmpty()) {
for (TradingDeal tr : tradingDealArrayList) {
if (tr.getId().equals(dotradeid)) {
tradingDeal = tr;
}
}
Card card = new DBConnection().getCardFromID(this.payload);
if (card != null) {
if (tradingDeal != null) {
if (tradingDeal.cardOk(card)) {
String json = JsonHelper.objToJson(card);
if (json != null && !json.isEmpty()) {
if (new DBConnection().addUserCard(username, tradingDeal.getCardToTrade().getName())) {
if (new DBConnection().delUserCard(tradingDeal.getUsername(), tradingDeal.getCardToTrade().getName())) {
if (new DBConnection().deleteTradingDeal(tradingDeal.getId())) {
if (new DBConnection().delUserCard(username, card.getName())) {
if (new DBConnection().addUserCard(tradingDeal.getUsername(), card.getName())) {
sendResponse(json, "200");
} else {
sendResponse("ERROR --> Add Card to: " + tradingDeal.getUsername(), "500");
}
} else {
sendResponse("ERROR --> Del Card from: " + username, "500");
}
} else {
sendResponse("Error --> Del Trading Deal", "500");
}
} else {
sendResponse("ERROR --> Del Card from: " + tradingDeal.getUsername(), "500");
}
} else {
sendResponse("ERROR --> Add Card to: " + username, "500");
}
} else {
sendResponse("ERROR --> JSON Empty", "500");
}
} else {
sendResponse("ERROR --> Trading Deal not ok", "500");
}
} else {
sendResponse("ERROR --> Trading Deal not exist", "500");
}
} else {
sendResponse("ERROR --> Card not exist", "500");
}
} else {
sendResponse("ERROR --> Trading Deal not exist", "500");
}
} else {
sendResponse("ERROR --> Username empty", "401");
}
} else {
//CREATE TRADING DEAL
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String id = (String) Objects.requireNonNull(map).get("Id");
String cardtotrade = (String) map.get("CardToTrade");
String type = (String) map.get("Type");
double mindamage = Double.parseDouble(map.get("MinimumDamage") + "");
String username = basicAuthGetUsername(this.authString);
if (username != null) {
Card cardtoTradeC = new DBConnection().getCardFromID(cardtotrade);
if (cardtoTradeC != null) {
TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, username);
String tradingJson = JsonHelper.objToJson(tradingDeal);
ArrayList<String> deckCards = new DBConnection().getDeck(username);
if (deckCards != null) {
if (deckCards.contains(cardtotrade)) {
new DBConnection().delDeck(username);
}
if (new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())) {
if (new DBConnection().updateCardLock(tradingDeal.getCardToTrade().getName(), true)) {
sendResponse(Objects.requireNonNull(JsonHelper.objToJson(tradingDeal)), "201");
} else {
sendResponse("", "500");
}
} else {
sendResponse("", "500");
}
} else {
sendResponse("", "500");
}
sendResponse(Objects.requireNonNull(tradingJson), "201");
} else {
sendResponse("", "500");
}
} else {
sendResponse("", "500");
}
}
}
}else if (this.url.startsWith("/battle")) {
if(login()){
String username = basicAuthGetUsername(this.authString);
if (username != null && !username.isEmpty()) {
List<String> deckNamen = new DBConnection().getDeck(username);
if (deckNamen != null && !deckNamen.isEmpty()) {
Cards deck = new DBConnection().getCardsFromIDList(deckNamen);
if(deck != null && deck.getCards().size() == 4) {
Battle openBattle = new DBConnection().getOpenBattle();
if (openBattle == null) {
//Creator player Mode
if(new DBConnection().addBattle(username)){
sendResponse("Du bist: #PLAYER 1\nBattle Einladung wurde erstellt von: " + username + "(#PLAYER1) \nSobald ein 2. Spieler dem Battle beitritt, kann das ergebnis mit /score abgefragt werden.","200");
}else {
sendResponse("", "500");
}
} else {
//Join game player
User player2 = new DBConnection().getUser(username);
if(player2 != null){
openBattle.setPlayer2(player2);
openBattle.setDeckPlayer2(deck);
if(new DBConnection().delBattleEinladung(openBattle.getId() + "")) {
if (openBattle.doFight()){
System.out.println(JsonHelper.objToJson(openBattle.getLog().size()));
if (new DBConnection().addBattleLog(openBattle.getId() + "", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1() + "", openBattle.getScorePlayer2() + "", openBattle.getLog().toString())) {
if (new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) {
//DEL OLD DECK CARDS
ArrayList<String> oldDeck1 = new ArrayList<>();
for (Card ca : openBattle.getDeckPlayer1Init().getCards()) {
oldDeck1.add(ca.getName());
}
ArrayList<String> oldDeck2 = new ArrayList<>();
for (Card ca : openBattle.getDeckPlayer2Init().getCards()) {
oldDeck2.add(ca.getName());
}
//DEL NEW CARDS IF EXIST
Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername());
for (Card ca : openBattle.getDeckPlayer1().getCards()) {
oldDeck1.add(ca.getName());
}
if (player1cards.getCards() != null && !player1cards.getCards().isEmpty()) {
for (String ca : oldDeck1) {
if (!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca)) {
sendResponse("Error Deleting user card1: " + ca, "500");
}
}
}
Cards player2cards = new DBConnection().getCards(openBattle.getPlayer2().getCredentials().getUsername());
for (Card ca : openBattle.getDeckPlayer2().getCards()) {
oldDeck2.add(ca.getName());
}
if (player2cards.getCards() != null && !player2cards.getCards().isEmpty()) {
for (String ca : oldDeck2) {
if (!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca)) {
sendResponse("Error Deleting user card2: " + ca, "500");
}
}
}
//ADD CARDS TO DECK
for (Card ca : openBattle.getDeckPlayer1().getCards()) {
if (!new DBConnection().addUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())) {
sendResponse("Error adding card to user1: " + ca.getName(), "500");
}
}
for (Card ca : openBattle.getDeckPlayer2().getCards()) {
if (!new DBConnection().addUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())) {
sendResponse("Error adding card to user2: " + ca.getName(), "500");
}
}
sendResponse("Du bist: #PLAYER 2\nBattle --> " + openBattle.getPlayer1().getName() + "(#PLAYER1) |vs| " + openBattle.getPlayer2().getName() + "(#PLAYER2)\nErgebnisse unter /score abrufbar", "200");
}
} else {
sendResponse("Battle Log konnte ned geschrieben werden", "500"); //ERROR
}
}else {
sendResponse("Battle konnte ned durchgeführt werden", "500");
}
}else{
sendResponse("Battle einladung konnte ned akzeptiert werden", "500"); //ERROR
}
}else{
sendResponse("GET User error", "500"); //ERROR
}
}
}else {
sendResponse("Nur "+ Objects.requireNonNull(deck).getCards().size()+" von 4 Karten im Deck. \nMach zuerst POST /deck [ID, ID, ID, ID] um dein Deck korrekt zu befüllen","424");
}
}else {
sendResponse("Deck ist nicht gesetzt","424");
}
}else {
sendResponse("", "500");
}
}else {
sendResponse("Login Error", "401");
}
} else{
sendResponse("", "405");
}
}
/**
* Prüft den Login, anhand des BasicAuth Base64 String
* @return True wenn login daten korrekt, sonst false
*/
private boolean login(){
if(this.authString != null && !this.authString.isEmpty()){
String username = basicAuthGetUsername(this.authString);
User user;
user = new DBConnection().getUser(username);
return basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString);
}else{
return false;
}
}
/**
* Alle Put Methoden
* Nur für angemeldete user erreichbar
*/
private void putMethodes(){
if (this.url.startsWith("/users")) {
String username = this.url.substring(this.url.lastIndexOf('/') + 1);
User user;
user = new DBConnection().getUser(username);
if(user != null) {
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String bio = (String) Objects.requireNonNull(map).get("Bio");
String image = (String) map.get("Image");
String name = (String) map.get("Name");
user.setBio(bio);
user.setImage(image);
user.setNachname(name);
if (new DBConnection().updateUser(username, user.getBio(), user.getImage(), user.getNachname())) {
sendResponse(JsonHelper.userToJson(user), "200");
} else {
sendResponse("", "500");
}
}else{
sendResponse("", "500");
}
}else if(this.url.startsWith("/deck")) {
List<String> deckIds = JsonHelper.jsonPayloadToList(this.payload);
if (deckIds != null && deckIds.size() == 4){
if (new DBConnection().setDeck(basicAuthGetUsername(this.authString), deckIds)){
Cards deck = new DBConnection().getCardsFromIDList(deckIds);
String deckJson = JsonHelper.objToJson(deck);
if (deck != null && deckJson != null){
sendResponse(deckJson, "200");
}else {
sendResponse("", "500");
}
}else {
sendResponse("", "500");
}
}else{
sendResponse(Objects.requireNonNull(deckIds).size() + " von 4 Karten sind im Deck.","500");
}
}
}
/**
* Alle Delete Methoden, siehe API beschreibung für genauere details
* Nur für angemeldete user erreichbar
*/
private void deleteMethodes(){
if (this.url.startsWith("/tradings")) {
String tradeid = this.url.substring(this.url.lastIndexOf('/') + 1);
ArrayList<TradingDeal> allTradingDeals = new DBConnection().getAllTradingDeals();
TradingDeal tr = null;
if (allTradingDeals != null && !allTradingDeals.isEmpty()) {
for (TradingDeal i : allTradingDeals) {
if (i.getId().equals(tradeid)) {
tr = i;
}
}
if (tr != null) {
if (new DBConnection().deleteTradingDeal(tradeid)) {
if (new DBConnection().updateCardLock(tr.getCardToTrade().getName(), false))
sendResponse("", "204");
} else {
sendResponse("", "500");
}
}else{
sendResponse("", "500");
}
}
}
}
/**
* Sendet eine Response
* @param responseText Text der zu senden ist
* @param code Http code
*/
private void sendResponse(String responseText, String code){
out.print("HTTP/1.0 "+code+"\r\n");
out.print("Server: Apache/0.8.4\r\n");
out.print("Content-Type: text/plain\r\n");
out.print("Content-Length: "+responseText.length()+"\r\n");
out.print("\r\n");
out.print(responseText);
}
}

50
src/test/java/CardTest.java Normal file
View File

@ -0,0 +1,50 @@
import at.reisinger.obj.Card;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class CardTest {
@Test
public void test_getName() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
assertEquals(card.getName(), "Name");
}
@Test
public void test_getDamage() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
assertEquals(card.getDamage(), 10);
}
@Test
public void test_getElementType() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
ElementTyp elementTyp = card.getElementTyp();
assertSame(elementTyp, ElementTyp.WATER);
}
@Test
public void test_getCardType() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
CardType cardType = card.getCardType();
assertSame(cardType, CardType.SPELL);
}
@Test
public void test_setName() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
card.setName("NeuerName");
assertEquals(card.getName(), "NeuerName");
}
@Test
public void test_setDamage() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
card.setDamage(100);
assertEquals(card.getDamage(), 100);
}
@Test
public void test_setElementTyp() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
card.setElementType(ElementTyp.FIRE);
assertSame(card.getElementTyp(), ElementTyp.FIRE);
}
}

76
src/test/java/CardsTest.java Normal file
View File

@ -0,0 +1,76 @@
import at.reisinger.obj.Card;
import at.reisinger.enums.CardType;
import at.reisinger.obj.Cards;
import at.reisinger.enums.ElementTyp;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.*;
public class CardsTest {
private Cards cards, cards2, cards3;
private Card newCard;
private Card card;
private ArrayList<Card> cardsArrayList;
@BeforeEach
void setUp() {
card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
Card newerCard = new Card("NameNewerer", 100, ElementTyp.FIRE, CardType.MONSTER);
cardsArrayList = new ArrayList<>();
ArrayList<Card> cardsArrayList2 = new ArrayList<>();
ArrayList<Card> cardsArrayList3 = new ArrayList<>();
cardsArrayList.add(card);
cardsArrayList2.add(newCard);
cardsArrayList2.add(card);
cardsArrayList3.add(newerCard);
cards = new Cards(cardsArrayList);
cards2 = new Cards(cardsArrayList2);
cards3 = new Cards(cardsArrayList3);
}
@Test
void test_addCard() {
System.out.println(cards.getCards().toString());
cards.addCard(newCard);
System.out.println(cards.getCards().toString());
System.out.println(cards2.getCards().toString());
assertTrue(cards.equals(cards2));
}
@Test
void test_addCard2() {
cards.addCard(newCard);
assertFalse(cards.equals(cards3));
}
@Test
void test_equals() {
assertFalse(cards.equals(cards2));
}
@Test
void test_contains() {
assertTrue(cards2.containsCard(card.getName()));
}
@Test
void test_contains2() {
assertFalse(cards.containsCard(newCard.getName()));
}
@Test
void test_delCard() {
cards.addCard(newCard);
cards.delCard(newCard);
assertEquals(cardsArrayList, cards.getCards());
}
@Test
void test_getCards() {
assertEquals(cardsArrayList, cards.getCards());
}
}

15
src/test/java/CoinsTest.java Normal file
View File

@ -0,0 +1,15 @@
import at.reisinger.obj.Coins;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
public class CoinsTest {
@Test
public void test_getCoinAmount(){
Coins coin = new Coins(10);
assertTrue(coin.getCoinAmount() >= 0);
}
}

49
src/test/java/PackageTest.java Normal file
View File

@ -0,0 +1,49 @@
import at.reisinger.obj.Card;
import at.reisinger.obj.Cards;
import at.reisinger.obj.Package;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class PackageTest {
private Package myPackage;
@BeforeEach
void setUp() {
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
Card newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
ArrayList<Card> cardsArrayList = new ArrayList<>();
ArrayList<Card> cardsArrayList2 = new ArrayList<>();
ArrayList<Card> cardsArrayList3 = new ArrayList<>();
cardsArrayList.add(card);
cardsArrayList2.add(newCard);
Cards cards = new Cards(cardsArrayList);
Cards newCards = new Cards(cardsArrayList2);
Cards nochNewCards = new Cards(cardsArrayList3);
myPackage = new Package(cards,"Name", 100);
}
@Test
void test_getName() {
String result = myPackage.getName();
assertEquals(result, "Name");
}
@Test
void test_getPrice() {
int result = myPackage.getPrice();
assertEquals(result, 100);
}
@Test
void test_setName() {
myPackage.setName("neuName");
String result = myPackage.getName();
assertEquals(result, "neuName");
}
}

92
src/test/java/TradingDealTest.java Normal file
View File

@ -0,0 +1,92 @@
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
import at.reisinger.obj.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.*;
public class TradingDealTest {
private TradingDeal tradingDeal;
private Card newCard, card;
@BeforeEach
void setUp() {
//at.reisinger.Stack
card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
ArrayList<Card> cardsArrayList = new ArrayList<>();
ArrayList<Card> cardsArrayList2 = new ArrayList<>();
ArrayList<Card> cardsArrayList3 = new ArrayList<>();
cardsArrayList.add(card);
cardsArrayList2.add(newCard);
Cards cards = new Cards(cardsArrayList);
Cards newCards = new Cards(cardsArrayList2);
Cards nochNewCards = new Cards(cardsArrayList3);
//at.reisinger.obj.Coins
Coins coins = new Coins(10);
//at.reisinger.obj.User
Credentials credentials = new Credentials("username", "passwort");
Credentials newCredentials = new Credentials("usernamenew", "passwortnew");
User user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
User userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE");
//Trading Deal
Card cardToTrade = card;
ElementTyp requiredElementType = ElementTyp.FIRE;
double requiredMinDamage = 100;
CardType requiredCardType = CardType.MONSTER;
tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME");
}
@Test
void test_getCardToTrade() {
Card result = tradingDeal.getCardToTrade();
assertTrue(result.equals(card));
}
@Test
void test_getRequiredElementType() {
ElementTyp result = tradingDeal.getRequiredElementType();
assertSame(result, ElementTyp.FIRE);
}
@Test
void test_getRequiredMinDamage() {
double result = tradingDeal.getRequiredMinDamage();
assertEquals(result, 100);
}
@Test
void test_getRequiredCardType() {
CardType result = tradingDeal.getRequiredCardType();
assertSame(result, CardType.MONSTER);
}
@Test
void test_setCardToTrade() {
tradingDeal.setCardToTrade(newCard);
Card result = tradingDeal.getCardToTrade();
assertSame(result, newCard);
}
@Test
void test_setRequiredElementType() {
tradingDeal.setRequiredElementType(ElementTyp.WATER);
ElementTyp result = tradingDeal.getRequiredElementType();
assertSame(result, ElementTyp.WATER);
}
@Test
void test_setRequiredMinDamage() {
tradingDeal.setRequiredMinDamage(10);
double result = tradingDeal.getRequiredMinDamage();
assertEquals(result, 10);
}
@Test
void test_setRequiredCardType() {
tradingDeal.setRequiredCardType(CardType.SPELL);
CardType result = tradingDeal.getRequiredCardType();
assertSame(result, CardType.SPELL);
}
}

85
src/test/java/UserTest.java Normal file
View File

@ -0,0 +1,85 @@
import at.reisinger.obj.*;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
import at.reisinger.obj.Package;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Objects;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class UserTest {
private TradingDeal tradingDeal;
private User user;
private Package myPackage;
@BeforeEach
void setUp() {
//at.reisinger.Stack
Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
Card newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
ArrayList<Card> cardsArrayList = new ArrayList<>();
ArrayList<Card> cardsArrayList2 = new ArrayList<>();
ArrayList<Card> cardsArrayList3 = new ArrayList<>();
cardsArrayList.add(card);
cardsArrayList2.add(newCard);
Cards cards = new Cards(cardsArrayList);
Cards newCards = new Cards(cardsArrayList2);
Cards nochNewCards = new Cards(cardsArrayList3);
//at.reisinger.obj.Package
myPackage = new Package(cards, "Name", 100);
//at.reisinger.obj.Coins
Coins coins = new Coins(10);
//at.reisinger.obj.User
Credentials credentials = new Credentials("username", "pw");
user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
}
@Test
public void test_getName() {
String result = user.getName();
assertEquals(result, "name");
}
@Test
public void test_getNachname() {
String result = user.getNachname();
assertEquals(result, "nachname");
}
@Test
public void test_getEmail() {
String result = user.getEmail();
assertEquals(result, "email");
}
@Test
public void test_setName() {
String newstring = "new";
user.setName(newstring);
String result = user.getName();
assertEquals(newstring, result);
}
@Test
public void test_setNachname() {
String newstring = "new";
user.setNachname(newstring);
String result = user.getNachname();
assertEquals(newstring, result);
}
@Test
public void test_setEmail() {
String newstring = "new";
user.setEmail(newstring);
String result = user.getEmail();
assertEquals(newstring, result);
}
@Test
public void test_buyPackage(){
Cards cards;
cards = new Cards(user.buyPackage(myPackage));
assertTrue(Objects.requireNonNull(cards).equals(new Cards(myPackage.getCards())));
}
}