Battle

src/main/java/at/reisinger/Battle.java

@@ -1,4 +1,521 @@
 package at.reisinger;
 
+import java.util.ArrayList;
+import java.util.Collections;
+
 public class Battle {
+
+    private User player1, player2;
+    private int scorePlayer1, scorePlayer2, id;
+    private Cards deckPlayer1, deckPlayer2, deckPlayer1Init, deckPlayer2Init;
+    private Card spielfeldCardPlayer1, spielfeldCardPlayer2;
+    private ArrayList<String> log = new ArrayList<String>();
+
+
+    /**
+     * Erstellt ein neues Battle
+     * @param player1 Player 1 Obj
+     * @param player2 Player 2 Obj
+     * @param scorePlayer1 Score PLayer 1
+     * @param scorePlayer2 Score player 2
+     * @param deckPlayer1 Deck Player 1
+     * @param deckPlayer2 Deck Player 2
+     */
+    public Battle(int id, User player1, User player2, int scorePlayer1, int scorePlayer2, Cards deckPlayer1, Cards deckPlayer2) {
+        this.id = id;
+        this.player1 = player1;
+        this.player2 = player2;
+        this.scorePlayer1 = scorePlayer1;
+        this.scorePlayer2 = scorePlayer2;
+        this.deckPlayer1 = deckPlayer1;
+        this.deckPlayer2 = deckPlayer2;
+        this.deckPlayer1Init = deckPlayer1;
+        this.deckPlayer2Init = deckPlayer2;
+        this.spielfeldCardPlayer1 = null;
+        this.spielfeldCardPlayer2 = null;
+    }
+
+    /**
+     * Erstellt ein neues Battle, im zustand offenes battle
+     * @param id
+     * @param player1
+     * @param deckPlayer1
+     */
+    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;
+        this.spielfeldCardPlayer1 = null;
+        this.spielfeldCardPlayer2 = null;
+    }
+
+    /**
+     * Startet einen Kampf zw den beiden Playern
+     * @return true bei erfolg, sonst false
+     */
+    public boolean doFight(){
+        System.out.println("DAS IS DAS BATTTTLLLLLLLEEEEEEEEEE FIIIIIGHT!");
+        System.out.println(player1.getName() + " |vs|" + player2.getName());
+        System.out.println(deckPlayer1.getCards().toString()+ " |vs| " + deckPlayer2.getCards().toString());
+
+        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;
+            for(int i = 0; d1.size()>i && d2.size()>i && i<maxroundcount; i++) {
+                System.out.println("Runde: " + i);
+                Card c1 = d1.get(i);
+                Card c2 = d2.get(i);
+                System.out.println("Card 1: " + c1.getElementTyp()+c1.getCardType() + "\nCard 2: "+c2.getElementTyp()+c2.getCardType());
+                //GLEICHER TYP Monster
+                if (!c1.getCardType().name().toUpperCase().equals("SPELL") && !c2.getCardType().name().toUpperCase().equals("SPELL")) {
+                    System.out.println("Same Monster");
+                    //Check ob eine der beiden Carten ein Dragon ist
+                    if ((c1.getCardType().name().toUpperCase().equals("DRANGON") && !c2.getCardType().name().toUpperCase().equals("DRANGON") || (!c1.getCardType().name().toUpperCase().equals("DRANGON") && c2.getCardType().name().toUpperCase().equals("DRANGON")))) {
+                        //Eine der Karten is Dragon
+                        System.out.println("Eine ist ein dragon");
+                        Card dragon = null;
+                        int dragonOwner = 0;
+                        if (c1.getCardType().name().toUpperCase().equals("DRAGON")) {
+                            dragon = c1;
+                            dragonOwner = 1;
+                        } else if (c2.getCardType().name().toUpperCase().equals("DRAGON")) {
+                            dragon = c2;
+                            dragonOwner = 2;
+                        } else {
+                            System.out.println("KEIN DRAGON GEFUNDEN");
+                            return false;
+                        }
+                        if ((c1.getCardType().name().toUpperCase().equals("GOBLIN") && !c2.getCardType().name().toUpperCase().equals("GOBLIN") || (!c1.getCardType().name().toUpperCase().equals("GOBLIN") && c2.getCardType().name().toUpperCase().equals("GOBLIN")))) {
+                            //Eine der Karten ist Goblin
+                            System.out.println("Andere ist ein goblin");
+                            Card goblin = null;
+                            if (c1.getCardType().name().toUpperCase().equals("GOBLIN")) {
+                                goblin = c1;
+                            } else if (c2.getCardType().name().toUpperCase().equals("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 if (dragonOwner == 2) {
+                                    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().toUpperCase().equals("ELF") && c1.getElementTyp().name().toUpperCase().equals("FIRE") && !c2.getCardType().name().toUpperCase().equals("ELF") || (!c1.getCardType().name().toUpperCase().equals("ELF") && c2.getElementTyp().name().toUpperCase().equals("FIRE") && c2.getCardType().name().toUpperCase().equals("ELF")))) {
+                            //Eine der Karten ist der Fire Elf die andere Karte ist der drache
+                            System.out.println("Andere ist ein elf");
+                            Card fireelf = null;
+                            if (dragonOwner == 1) {
+                                fireelf = c2;
+                            } else if (dragonOwner == 2) {
+                                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 if (dragonOwner == 2) {
+                                    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().toUpperCase().equals("WIZZARD") && c2.getCardType().name().toUpperCase().equals("ORK") || (c2.getCardType().name().toUpperCase().equals("WIZZARD") && c1.getCardType().name().toUpperCase().equals("ORK")))){
+                        System.out.println("Eine wizzard Andere ist ein ork");
+                        Card wizzard = null;
+                        Card ork = null;
+                        int wizzardOwner = 0;
+                        if(c1.getCardType().name().toUpperCase().equals("WIZZARD")){
+                            wizzardOwner = 1;
+                            wizzard = c1;
+                            ork = c2;
+                        }else if(c1.getCardType().name().toUpperCase().equals("WIZZARD")){
+                            wizzardOwner = 2;
+                            wizzard = c2;
+                            ork = c1;
+                        }
+                        if(wizzard.getDamage() > ork.getDamage()){
+                            if(wizzardOwner == 1){
+                                d1.add(c2);
+                                d2.remove(c2);
+                              this.scorePlayer1 += 3;
+                              this.scorePlayer2 -= 5;
+                            }else if (wizzardOwner == 2){
+                                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().toUpperCase().equals("KNIGHT") || c2.getCardType().name().toUpperCase().equals("KNIGHT")){
+                        //Mixed mit "Spezialeffekt" KNIGHT
+                        System.out.println("Spell und knight");
+                        Card knight =null, other = null;
+                        int knightOwner = 0;
+                        if(c1.getCardType().name().toUpperCase().equals("KNIGHT")){
+                            knight = c1;
+                            other = c2;
+                            knightOwner = 1;
+                        }else if(c2.getCardType().name().toUpperCase().equals("KNIGHT")){
+                            knight = c2;
+                            other = c1;
+                            knightOwner = 2;
+                        }
+                        double damageKnight = -1, damageOther = -1;
+                        if (other.getElementTyp().name().toUpperCase().equals("WATER")){
+                            //tot
+                            damageKnight = 0;
+                            damageOther = other.getDamage();
+                        }else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("REGULAR")) {
+                            //not effective
+                            damageKnight = knight.getDamage() / 2;
+                            //effective
+                            damageOther = other.getDamage() *2;
+                        } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("FIRE")) {
+                            //no effect
+                            damageKnight = knight.getDamage();
+                            //no effect
+                            damageOther = other.getDamage();
+                        }else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("WATER")) {
+                            //effective
+                            damageKnight = knight.getDamage() * 2;
+                            //not effective
+                            damageOther = other.getDamage() / 2;
+                        }else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("REGULAR")) {
+                            //no effect
+                            damageKnight = knight.getDamage();
+                            //no effect
+                            damageOther = other.getDamage();
+                        } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("FIRE")) {
+                            //effective
+                            damageKnight = knight.getDamage() * 2;
+                            //not effective
+                            damageOther = other.getDamage() / 2;
+                        }else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && 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 if(knightOwner == 2){
+                                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 if(knightOwner == 1){
+                                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().toUpperCase().equals("KRAKEN") || c2.getCardType().name().toUpperCase().equals("KRAKEN")){
+                        //Mixed mit "Spezialeffekt" KRAKEN
+                        if(c1.getCardType().name().toUpperCase().equals("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().toUpperCase().equals("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
+                        if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                            if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                //effective
+                                damagePlayer1 = c1.getDamage() * 2;
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                //not effective
+                                damagePlayer1 = c1.getDamage() / 2;
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                //no effect
+                                damagePlayer1 = c1.getDamage();
+                            }
+                        } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                            if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                //effective
+                                damagePlayer1 = c1.getDamage() * 2;
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                //no effect
+                                damagePlayer1 = c1.getDamage();
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                //not effective
+                                damagePlayer1 = c1.getDamage() / 2;
+                            }
+                        } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                            if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                //effective
+                                damagePlayer1 = c1.getDamage() * 2;
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                //not effective
+                                damagePlayer1 = c1.getDamage() / 2;
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                //no effect
+                                damagePlayer1 = c1.getDamage();
+                            }
+                        }
+                        //P2 damage
+                        if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                            if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                //effective
+                                damagePlayer2 = c2.getDamage() * 2;
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                //not effective
+                                damagePlayer2 = c2.getDamage() / 2;
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                //no effect
+                                damagePlayer2 = c2.getDamage();
+                            }
+                        } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                            if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                //effective
+                                damagePlayer2 = c2.getDamage() * 2;
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                //no effect
+                                damagePlayer2 = c2.getDamage();
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                //not effective
+                                damagePlayer2 = c2.getDamage() / 2;
+                            }
+                        } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                            if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                //effective
+                                damagePlayer2 = c2.getDamage() * 2;
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                //not effective
+                                damagePlayer2 = c2.getDamage() / 2;
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                //no effect
+                                damagePlayer2 = c2.getDamage();
+                            }
+                        }
+
+                        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;
+                        }
+                    }
+                }
+            }
+            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;
+    }
+
+    /**
+     * Vergleicht 2 Card Typen von 2 Karten
+     * @param c1 Card 1
+     * @param c2 Card 2
+     * @return True wenn die CardType übereinstimmt, sonst false
+     */
+    private boolean sameCardType(Card c1, Card c2){
+        if(c1.getCardType().name().equals(c2.getCardType().name())){
+            return true;
+        }
+        return false;
+    }
+
+    public ArrayList<String> getLog() {
+        return log;
+    }
+
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public User getPlayer1() {
+        return player1;
+    }
+
+    public void setPlayer1(User player1) {
+        this.player1 = player1;
+    }
+
+    public User getPlayer2() {
+        return player2;
+    }
+
+    public void setPlayer2(User player2) {
+        this.player2 = player2;
+    }
+
+    public int getScorePlayer1() {
+        return scorePlayer1;
+    }
+
+    public void setScorePlayer1(int scorePlayer1) {
+        this.scorePlayer1 = scorePlayer1;
+
+    }
+
+    public int getScorePlayer2() {
+        return scorePlayer2;
+    }
+
+    public void setScorePlayer2(int scorePlayer2) {
+        this.scorePlayer2 = scorePlayer2;
+    }
+
+    public Cards getDeckPlayer1() {
+        return deckPlayer1;
+    }
+
+    public void setDeckPlayer1(Cards deckPlayer1) {
+        this.deckPlayer1 = deckPlayer1;
+        this.deckPlayer1Init = deckPlayer1;
+    }
+
+    public Cards getDeckPlayer2() {
+        return deckPlayer2;
+    }
+
+    public void setDeckPlayer2(Cards deckPlayer2) {
+        this.deckPlayer2 = deckPlayer2;
+        this.deckPlayer2Init = deckPlayer2;
+    }
+
+    public Card getSpielfeldCardPlayer1() {
+        return spielfeldCardPlayer1;
+    }
+
+    public void setSpielfeldCardPlayer1(Card spielfeldCardPlayer1) {
+        this.spielfeldCardPlayer1 = spielfeldCardPlayer1;
+    }
+
+    public Card getSpielfeldCardPlayer2() {
+        return spielfeldCardPlayer2;
+    }
+
+    public void setSpielfeldCardPlayer2(Card spielfeldCardPlayer2) {
+        this.spielfeldCardPlayer2 = spielfeldCardPlayer2;
+    }
+
+    public Cards getDeckPlayer1Init() {
+        return deckPlayer1Init;
+    }
+
+    public Cards getDeckPlayer2Init() {
+        return deckPlayer2Init;
+    }
 }

src/main/java/at/reisinger/Card.java

@@ -1,5 +1,6 @@
 package at.reisinger;
 
+import at.reisinger.server.helper.EnumHelper;
 import com.fasterxml.jackson.annotation.*;
 
 /**
@@ -15,6 +16,8 @@ public class Card {
     private ElementTyp elementTyp;
     @JsonProperty
     private CardType cardType;
+    @JsonProperty
+    private boolean locked;
 
     /**
      * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften
@@ -39,46 +42,70 @@ public class Card {
      */
     @JsonCreator
     public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
-        ElementTyp tmpElement = stringToElementType(elementCardTyp);
+        CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
-        if(tmpElement == null){
+        ElementTyp tmpElement = null;
-            tmpElement = ElementTyp.UNDEF;
-        }
-        CardType tmpCard = stringToCardType(elementCardTyp);
         if(tmpCard == null){
             tmpCard = CardType.UNDEF;
         }
+
+        //Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen
+        if (tmpCard.name().toLowerCase().equals("dragon")){
+            tmpElement = ElementTyp.FIRE;
+        }else if (tmpCard.name().toLowerCase().equals("ork")){
+            tmpElement = ElementTyp.REGULAR;
+        }
+        else if (tmpCard.name().toLowerCase().equals("wizzard")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("kraken")){
+            tmpElement = ElementTyp.WATER;
+        }else if (tmpCard.name().toLowerCase().equals("elf")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("goblin")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("troll")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("knight")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("fireelves")){
+            tmpElement = ElementTyp.FIRE;
+        }
+
+        if(tmpElement == null){
+            tmpElement = EnumHelper.stringToElementType(elementCardTyp);
+            //Deutsch übersetzung
+            if (tmpElement.name().toLowerCase().equals("feuer")){
+                tmpElement = ElementTyp.FIRE;
+            }else if (tmpElement.name().toLowerCase().equals("wasser")){
+                tmpElement = ElementTyp.WATER;
+            }else if (tmpElement.name().toLowerCase().equals("normal")){
+                tmpElement = ElementTyp.REGULAR;
+            }
+            if(tmpElement == null) {
+                tmpElement = ElementTyp.UNDEF;
+            }
+        }
         this.name = name;
         this.damage = damage;
         this.elementTyp = tmpElement;
         this.cardType = tmpCard;
     }
 
+
+
     /**
-     * Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück
+     * Prüft ob die Karte gesperrt ist
-     * @param elementTypeString elementType als String
+     * @return True wenn die Karte gesperrt ist
-     * @return Passender Element Type oder null falls nicht gefunden
      */
-    private ElementTyp stringToElementType(String elementTypeString){
+    public boolean isLocked() {
-        for (ElementTyp e : ElementTyp.values()) {
+        return locked;
-            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
+     * Setzt die sperre der Karte
-     * @param cardTypeString cardType als String
+     * @param locked True bedeuted gesperrt
-     * @return Passender Card Type oder null falls nicht gefunden
      */
-    private CardType stringToCardType(String cardTypeString){
+    public void setLocked(boolean locked) {
-        for (CardType me : CardType.values()) {
+        this.locked = locked;
-            if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
-                return me;
-            }
-        }
-        return null;
     }
 
     /**

src/main/java/at/reisinger/CardType.java

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

src/main/java/at/reisinger/Cards.java

@@ -23,7 +23,13 @@ public class Cards {
         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.Card hinzu
@@ -56,10 +62,10 @@ public class Cards {
      * @param toCeck at.reisinger.Card nach der in den at.reisinger.Cards gesucht werden soll
      * @return True wenn die at.reisinger.Card in den at.reisinger.Cards ist
      */
-    public boolean containsCard(Card toCeck){
+    public boolean containsCard(String toCeck){
         AtomicBoolean returnval = new AtomicBoolean(false);
         this.cards.forEach(item -> {
-            if(item.getElementTyp().equals(toCeck.getElementTyp()) && item.getCardType().equals(toCeck.getCardType()) && item.getName().equals(toCeck.getName()) && item.getDamage() == toCeck.getDamage()){
+            if(item.getName().equals(toCeck)){
                 returnval.set(true);
             }else{
                 returnval.set(false);

src/main/java/at/reisinger/DBConnection.java

@@ -1,9 +1,13 @@
 package at.reisinger;
 
+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
@@ -33,8 +37,377 @@ public class DBConnection {
         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);");
+        PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS battle_log_id_uindex on battle_log (id);", "Battle_lgo Table created");
     }
 
+    /**
+     * 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()){
+                    System.out.println("insert into battle (usernamecreator, deckcreator) VALUES (\'"+ usernamecreator + "\',\'" + deckJson +"\');");
+                    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();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        int battleid = 0;
+        String usernamecreator = "", deckcreator = "";
+        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");
+                deckcreator = rs.getString("deckcreator");
+                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){
+        return PostgresHelper.executeUpdate("insert into battle_log (id, playerone, playertwo, playeronescore, playertwoscore) VALUES ("+id+",\'"+playerone+"\',\'"+playertwo+"\',\'"+playeronescore+"\',\'"+playertwoscore+"\');");
+    }
+
+    /**
+     * Holt alle logs von allen battles
+     * @return Jedes Battle ist in einer Map mit namen von player1 und player2, player1Score und player2Score diese Map ist in einer ArrayList
+     */
+    public ArrayList<Map<String,Object>> getAllBattleLogs(){
+        this.c = PostgresHelper.con();
+        String player1Str, player2Str, scorePlayer1, scorePlayer2;
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from battle_log;");
+            ArrayList<Map<String, Object>> output = new ArrayList<Map<String, Object>>();
+            while (rs.next()) {
+                Map<String, Object> map = Collections.emptyMap();
+                player1Str = rs.getString("playerone");
+                player2Str = rs.getString("playertwo");
+                scorePlayer1 = rs.getString("playeronescore");
+                scorePlayer2 = rs.getString("playertwoscore");
+
+                User player1 = new DBConnection().getUser(player1Str);
+                User player2 = new DBConnection().getUser(player2Str);
+
+                if(player1 != null && player2 != null){
+                    map.put("player1", player1);
+                    map.put("player2", player2);
+                    map.put("playeronescore", scorePlayer1);
+                    map.put("playertwoscore", scorePlayer2);
+                    output.add(map);
+                }else{
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+            return null;
+        }
+        return null;
+    }
+
+    /**
+     * Holt das Battellog eines Bestimmten Battles
+     * @param battleid Id des battles
+     * @return Eine Map mit namen von player1 und player2, player1Score und player2Score
+     */
+    public Map<String, Object> getBattleLog(String battleid){
+        this.c = PostgresHelper.con();
+        String player1Str, player2Str, scorePlayer1, scorePlayer2;
+        Map<String, Object> map = Collections.emptyMap();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from battle_log where id = \'" + battleid + "\';");
+            while (rs.next()) {
+                player1Str = rs.getString("playerone");
+                player2Str = rs.getString("playertwo");
+                scorePlayer1 = rs.getString("playeronescore");
+                scorePlayer2 = rs.getString("playertwoscore");
+
+                User player1 = new DBConnection().getUser(player1Str);
+                User player2 = new DBConnection().getUser(player2Str);
+
+                if(player1 != null && player2 != null){
+                    map.put("player1", player1);
+                    map.put("player2", player2);
+                    map.put("playeronescore", scorePlayer1);
+                    map.put("playertwoscore", scorePlayer2);
+                    return map;
+                }else{
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+            return null;
+        }
+        return null;
+    }
+
+    /**
+     * 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();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        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();
+        System.out.println("Trading Deals pulled successfully");
+        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){
+        if(PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES (\'" + username + "\',\'" + id + "\',\'" + cardtotrade + "\',\'"+ mindamage + "\',\'" + reqcardtype + "\',\'" + reqelement + "\');")){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    /**
+     * Holt alle Trading Deals aus der DB
+     * @return Null bei error
+     */
+    public ArrayList<TradingDeal> getAllTradingDeals(){
+        this.c = PostgresHelper.con();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        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);
+                    if (tmp != null){
+                        tradingDeals.add(tmp);
+                        System.out.println("Pulled TradingDeal");
+                    }else{
+                        return null;
+                    }
+                }else{
+                    return null;
+                }
+
+
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Trading Deals pulled successfully");
+        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;
+            }
+        }
+        if (!delDeck(username)){
+            return false;
+        }
+        Cards allCards = getCards(username);
+        Cards deckCards = new Cards(new ArrayList<Card>());
+        int count = 0;
+        if(allCards != null){
+            for (String st : deck) {
+                for (Card ca: allCards.getCards()) {
+                    System.out.println("Count : " + count);
+                    System.out.println("CA: " + ca.getName() + " st: " + st);
+                    if(ca.getName().equals(st) && count < 4){
+                        deckCards.addCard(ca);
+                        if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES (\'"+username+"\', \'"+st+"\');", "Card #"+count+" added to Deck")){
+                            return false;
+                        }
+                    }
+                }
+                count++;
+            }
+            return true;
+        }
+        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 = "";
+        Cards allCards = new Cards(new ArrayList<Card>());
+        ArrayList<String> cardnamenarray = new ArrayList<String>();
+        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);
+                System.out.println("cardname = " + cardname);
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Deck names pulled successfully");
+        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
      *
@@ -83,18 +456,9 @@ public class DBConnection {
                 damage = rs.getInt("damage");
                 Card newCard = new Card(cardname, elementtyp + cardtype, damage);
                 cards.addCard(newCard);
-                Connection b = PostgresHelper.con();
+                if(!addUserCard(username, newCard.getName())){
-                try {
-                    stmt = b.createStatement();
-                    String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');";
-                    stmt.executeUpdate(sql);
-                    stmt.close();
-                    b.close();
-                } catch (Exception e) {
-                    System.err.println(e.getClass().getName() + ": " + e.getMessage());
                     return null;
                 }
-                System.out.println("User got Card successfully");
             }
             rs.close();
             stmt.close();
@@ -113,6 +477,37 @@ public class DBConnection {
         }
     }
 
+    /**
+     * 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;
+        }
+        System.out.println("User got Card successfully");
+        return true;
+    }
     /**
      * Löscht ein Package anhand des Namens
      *
@@ -313,31 +708,50 @@ public class DBConnection {
     }
 
     /**
-     * Holt alle Karten eines Users
+     * Holt eine Card aus der DB, anhand der gegebenen Card Id
-     * @param username Username des Users
+     * @param id Id der Card die geholt werden soll
-     * @return Cards Object, falls es null ist, war ein fehler
+     * @return Null bei error
      */
-    public Cards getCards(String username){
+    public Card getCardFromID(String id){
-        this.c = PostgresHelper.con();
+        System.out.println(id);
-        String cardname = "";
+        Connection b = PostgresHelper.con();
-        Cards allCards = new Cards(new ArrayList<Card>());
+        Card toreturn = null;
-        ArrayList<String> cardnamenarray = new ArrayList<String>();
         try {
-            stmt = this.c.createStatement();
+            stmt = b.createStatement();
-            ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';");
+            ResultSet rs = stmt.executeQuery("select * from card where NAME =  \'" + id + "\';");
             while (rs.next()) {
-                cardname = rs.getString("name");
+                int damage =rs.getInt("damage");
-                cardnamenarray.add(cardname);
+                String elementtyp =rs.getString("elementtyp");
-                System.out.println("cardname = " + cardname);
+                String cardtype=rs.getString("cardtype");
+                System.out.println("damage = " + damage);
+                System.out.println("elementtyp = " + elementtyp);
+                System.out.println("cardtype = " + cardtype);
+                System.out.println();
+                toreturn = new Card(id, elementtyp+cardtype, damage);
             }
             rs.close();
             stmt.close();
-            this.c.close();
+            b.close();
         } catch (Exception e) {
             System.err.println(e.getClass().getName() + ": " + e.getMessage());
-            System.exit(0);
+            return null;
         }
-        System.out.println("Card Namen pulled successfully");
+        if (toreturn != null){
+            System.out.println("Card pulled successfully");
+            return toreturn;
+        }else {
+            System.out.println("Card NOT pulled");
+            return null;
+        }
+    }
+
+    /**
+     * 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<Card>());
         for (String st : cardnamenarray) {
             Connection b = PostgresHelper.con();
             try {
@@ -358,14 +772,44 @@ public class DBConnection {
                 b.close();
             } catch (Exception e) {
                 System.err.println(e.getClass().getName() + ": " + e.getMessage());
-                System.exit(0);
+                return null;
             }
             System.out.println("Card pulled successfully");
         }
-
         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 = "";
+        boolean locked;
+        Cards allCards = new Cards(new ArrayList<Card>());
+        ArrayList<String> cardnamenarray = new ArrayList<String>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';");
+            while (rs.next()) {
+                cardname = rs.getString("name");
+                locked = rs.getBoolean("gesperrt");
+                cardnamenarray.add(cardname);
+                System.out.println("cardname = " + cardname);
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Card Namen pulled successfully");
+        return getCardsFromIDList(cardnamenarray);
+    }
+
     /**
      * Holt alle verfügbaren TradingDeals
      *

src/main/java/at/reisinger/ElementTyp.java

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

src/main/java/at/reisinger/TradingDeal.java

@@ -1,43 +1,99 @@
 package at.reisinger;
 
+import at.reisinger.server.helper.EnumHelper;
+import com.fasterxml.jackson.annotation.*;
+
 /**
  * Ein einzelner Trading deal wird hier verwaltet.
  */
+@JsonAutoDetect
 public class TradingDeal {
-    //private User tradingUser;
+    @JsonProperty
+    private String id, username;
+    @JsonProperty
     private Card cardToTrade;
+    @JsonProperty
     private ElementTyp requiredElementType;
+    @JsonProperty
     private double requiredMinDamage;
+    @JsonProperty
     private CardType requiredCardType;
 
     /**
-     * Ein at.reisinger.TradingDeal wird  erstellt
+     * Ein TradingDeal wird  erstellt
-     * @param user at.reisinger.User des Deals
+     * @param id Id des Trading deals
      * @param cardToTrade at.reisinger.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.Card Type für den Tausch
      */
-    public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) {
+    public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) {
-        //this.tradingUser = user;
+        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;
     }
 
     /**
-     * Holt den Trading at.reisinger.User
+     * Ein TradingDeal wird  erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt
-     * @return at.reisinger.User der den Trade erstellt hat
+     * @param id Id des Trading deals
-
+     * @param cardToTrade at.reisinger.Card die getauscht werden soll
-    public User getTradingUser() {
+     * @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
-        return this.tradingUser;
+     *             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;
+    }
+
+    /**
+     * Setzt die id des TradingDeals
+     * @param id Id des TradingDeals
+     */
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    /**
+     * Holt den usernamen
+     * @return Der username als String
+     */
+    @JsonGetter
+    public String getUsername() {
+        return username;
+    }
+
+    /**
+     * Setzt den usernamen
+     * @param username Der username als String
+     */
+    @JsonSetter
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+
     /**
      * at.reisinger.Card die getraded werden soll
      * @return at.reisinger.Card die getradet werden soll
      */
+    @JsonGetter
     public Card getCardToTrade() {
         return this.cardToTrade;
     }
@@ -46,6 +102,7 @@ public class TradingDeal {
      * Req Element type holen
      * @return Req Element Type
      */
+    @JsonGetter
     public ElementTyp getRequiredElementType() {
         return this.requiredElementType;
     }
@@ -54,6 +111,7 @@ public class TradingDeal {
      * Req min damage holen
      * @return Req min damage
      */
+    @JsonGetter
     public double getRequiredMinDamage() {
         return this.requiredMinDamage;
     }
@@ -62,6 +120,7 @@ public class TradingDeal {
      * Hole req cardtype
      * @return Req at.reisinger.CardType
      */
+    @JsonGetter
     public CardType getRequiredCardType() {
         return this.requiredCardType;
     }
@@ -78,6 +137,7 @@ public class TradingDeal {
      * Setzt die Karte die Getradet werden soll
      * @param cardToTrade at.reisinger.Card zum tauschen
      */
+    @JsonSetter
     public void setCardToTrade(Card cardToTrade) {
         this.cardToTrade = cardToTrade;
     }
@@ -86,6 +146,7 @@ public class TradingDeal {
      * Setzt req elementType
      * @param requiredElementType Der Req elementType
      */
+    @JsonSetter
     public void setRequiredElementType(ElementTyp requiredElementType) {
         this.requiredElementType = requiredElementType;
     }
@@ -94,6 +155,7 @@ public class TradingDeal {
      * Setzt die req Min damage
      * @param requiredMinDamage Die req min gamage
      */
+    @JsonSetter
     public void setRequiredMinDamage(double requiredMinDamage) {
         this.requiredMinDamage = requiredMinDamage;
     }
@@ -102,6 +164,7 @@ public class TradingDeal {
      * Setzt req cardType
      * @param requiredCardType Der Req at.reisinger.CardType
      */
+    @JsonSetter
     public void setRequiredCardType(CardType requiredCardType) {
         this.requiredCardType = requiredCardType;
     }

src/main/java/at/reisinger/server/Main.java

@@ -1,7 +1,6 @@
 package at.reisinger.server;
 
 import at.reisinger.DBConnection;
-import at.reisinger.server.msg.MsgHandler;
 import at.reisinger.server.objects.Request;
 import at.reisinger.server.objects.Response;
 
@@ -17,7 +16,6 @@ public class Main {
     static final int port = 80;
     private Socket socket;
     private int id;
-    private MsgHandler msgHandler;
 
     /**
      * Initial Start
@@ -58,7 +56,9 @@ public class Main {
         try{
             System.out.println("Socket von Client #" + this.id + " wurde gestartet!");
             Request rq = new Request(this.socket, this.id);
-            Response rp = new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload());
+            System.out.println("req done");
+            new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload());
+            System.out.println("res done");
             //this.msgHandler = rp.getMsghandler();
             this.socket.close();
             System.out.println("Socket von Client #" + this.id + " wurde geschlossen!");

src/main/java/at/reisinger/server/helper/EnumHelper.java

@@ -1,2 +1,38 @@
-package at.reisinger.server.helper;public class EnumHelper {
+package at.reisinger.server.helper;
+
+import at.reisinger.CardType;
+import at.reisinger.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;
+    }
 }

src/main/java/at/reisinger/server/helper/JsonHelper.java

@@ -9,6 +9,7 @@ import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -48,6 +49,49 @@ public class JsonHelper {
         }
     }
 
+    /**
+     * Json wird in ein Card Objekt umgewandelt
+     * @param json Json das umgewandelt werden soll
+     * @return Null bei JsonProcessingException
+     */
+    public static Card jsonToCard(String json){
+        ObjectMapper objectMapper = new ObjectMapper();
+        Card card = null;
+        try {
+           card = objectMapper.readValue(json, Card.class);
+           if(card != null) {
+               return card;
+           }else{
+               return null;
+           }
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+            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<List<String>>(){});
+        } 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 {
@@ -58,21 +102,9 @@ public class JsonHelper {
         }
     }
 
+    @Deprecated
     public static String userToJson(User user){
-        //User to json
+        return objToJson(user);
-        ObjectMapper objectMapper = new ObjectMapper();
-        objectMapper = new ObjectMapper();
-        String userJson = "";
-        if(user != null) {
-            try {
-                userJson += objectMapper.writeValueAsString(user);
-            } catch (JsonProcessingException e) {
-                userJson = "Error: JsonProcessingException -> " + e.getMessage();
-            }
-            return userJson;
-        }else{
-            return null;
-        }
     }
 
 }

src/main/java/at/reisinger/server/objects/Msg.java

@@ -1,37 +0,0 @@
-package at.reisinger.server.objects;
-
-/**
- * Message Objekt beinmhaltet die MsgId und die Msg selbst
- * @author Georg Reisinger
- */
-public class Msg {
-    private int id;
-    private String msg;
-
-    /**
-     * Erstellt eine Message
-     */
-    public Msg(int id, String msg){
-        this.id = id;
-        this.msg = msg;
-    }
-
-
-    /**
-     * get field
-     *
-     * @return id Message Id
-     */
-    public int getId() {
-        return this.id;
-    }
-
-    /**
-     * get field
-     *
-     * @return msg Message String
-     */
-    public String getMsg() {
-        return this.msg;
-    }
-}

src/main/java/at/reisinger/server/objects/Request.java

@@ -65,16 +65,24 @@ public class Request {
             headers.add(header);
         }
 
-        int authIndex = headers.toString().indexOf("Authorization");
-        String authString = headers.toString().substring(authIndex + 21);
-        int authIndexEnd = authString.indexOf(',');
-        authString = authString.substring(0, authIndexEnd);
 
-        this.authString = authString;
 
         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);
+            System.out.println("AUTH STRING: " + authString);
+            int authIndexEnd = authString.indexOf(',');
+            System.out.println("INDEX OF: " + authIndexEnd);
+            authString = authString.substring(0, authIndexEnd);
+            System.out.println("AUTH STRING: " + authString);
+
+            this.authString = authString;
+        }else{
+            this.authString = null;
+        }
     }
 
     /**

src/main/java/at/reisinger/server/objects/Response.java

@@ -4,7 +4,6 @@ import at.reisinger.*;
 import at.reisinger.Package;
 import at.reisinger.server.helper.JsonHelper;
 import at.reisinger.server.helper.PostgresHelper;
-import at.reisinger.server.msg.MsgHandler;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -111,6 +110,39 @@ public class Response {
             }else{
                 sendError("500");
             }
+        }else if(this.url.startsWith("/deck")) {
+            String format = this.url.substring(this.url.lastIndexOf('?') + 1);
+            System.out.println("Format in /deck?{format=plain}: " + format);
+            String username = basicAuthGetUsername(this.authString);
+            ArrayList<String> allCards = new DBConnection().getDeck(username);
+            Cards deck = null;
+            Object tmp = null;
+            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 {
+                sendError("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 != ""){
+                    sendResponse(json, "200");
+                }else{
+                    sendError("500");
+                }
+            }else{
+                sendError("500");
+            }
+        }else{
+            sendError("204");
         }
     }
 
@@ -203,8 +235,7 @@ public class Response {
                 sendError("401");
             }
         }else if (this.url.startsWith("/packages")) {
-            if(login()) {
+            if (basicAuth("admin", "istrator", this.authString)) {
-                if (basicAuth("admin", "admin", this.authString)) {
                 ObjectMapper objectMapper = new ObjectMapper();
                 ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>() {
                 });
@@ -222,7 +253,6 @@ public class Response {
             } else {
                 sendError("401");
             }
-            }
         }else if (this.url.startsWith("/transactions/packages")) {
             if (login()) {
                 DBConnection db = new DBConnection();
@@ -237,8 +267,232 @@ public class Response {
                         sendResponse(packageJson, "200");
                     }
                 }
+            }else{
+                sendError("401");
+            }
+        }else if (this.url.startsWith("/tradings")) {
+            if(login()) {
+                String dotradeid = this.url.substring(this.url.lastIndexOf('/') + 1);
+                System.out.println("DO TradeID in /tradings/{tradeID}: " + dotradeid);
+                if (!dotradeid.isEmpty() && dotradeid != null && !dotradeid.equals("tradings")) {
+                    //DO TRADE
+                    String username = basicAuthGetUsername(this.authString);
+                    if (username != null && !username.isEmpty()) {
+                        System.out.println(this.payload);
+                        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 {
+                                                                sendError("500");
+                                                            }
+                                                        } else {
+                                                            sendError("500");
+                                                        }
+                                                    } else {
+                                                        sendError("500");
+                                                    }
+                                                } else {
+                                                    sendError("500");
+                                                }
+                                            } else {
+                                                sendError("500");
+                                            }
+                                        } else {
+                                            sendError("500");
+                                        }
+                                    } else {
+                                        sendError("500");
+                                    }
+                                } else {
+                                    sendError("500");
+                                }
+                            } else {
+                                sendError("500");
+                            }
+                        } else {
+                            sendError("500");
+                        }
+                    } else {
+                        sendError("401");
+                    }
+                } else {
+                    //CREATE TRADING DEAL
+                    Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
+                    String id = (String) 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);
+                        System.out.println("CARD TO TRAD: " + cardtoTradeC.getName());
+                        if (cardtoTradeC != null) {
+                            TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, username);
+                            if (tradingDeal != null) {
+                                String tradingJson = JsonHelper.objToJson(tradingDeal);
+                                if (tradingDeal != null) {
+                                    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(JsonHelper.objToJson(tradingDeal), "201");
+                                            } else {
+                                                sendError("500");
+                                            }
+                                        } else {
+                                            sendError("500");
+                                        }
+                                    } else {
+                                        sendError("500");
+                                    }
+                                    sendResponse(tradingJson, "201");
+                                } else {
+                                    sendError("500");
+                                }
+                            } else {
+                                sendError("500");
+                            }
+                        } else {
+                            sendError("500");
+                        }
+                    } else {
+                        sendError("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 {
+                                    sendError("500");
+                                }
+
+                            } else {
+                                //Join game player
+                                try {
+                                    User player2 = new DBConnection().getUser(username);
+                                    if(player2 != null){
+                                        openBattle.setPlayer2(player2);
+                                        openBattle.setDeckPlayer2(deck);
+                                        if(new DBConnection().delBattleEinladung(openBattle.getId() + "")){
+                                            openBattle.doFight();
+                                            System.out.println(JsonHelper.objToJson(openBattle.getLog()));
+                                            if(new DBConnection().addBattleLog(openBattle.getId()+"", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1()+"", openBattle.getScorePlayer2() +"")){
+                                                if(new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) {
+                                                    //DEL OLD DECK CARDS
+                                                    for (Card ca: openBattle.getDeckPlayer1Init().getCards()){
+                                                        if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){
+                                                            sendResponse("Error Deleting user card1: " + ca.getName(), "500");
+                                                        }
+                                                    }
+                                                    for (Card ca: openBattle.getDeckPlayer2Init().getCards()){
+                                                        if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){
+                                                            sendResponse("Error Deleting user card2: " + ca.getName(), "500");
+                                                        }
+                                                    }
+                                                    //DEL NEW CARDS IF EXIST
+                                                    Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername());
+                                                    ArrayList<String> player1CardsList = new ArrayList<String>();
+                                                    for(Card ca:player1cards.getCards()){
+                                                        player1CardsList.add(ca.getName());
+                                                    }
+                                                    if(player1cards.getCards() != null && !player1cards.getCards().isEmpty()) {
+                                                        for (Card ca : openBattle.getDeckPlayer1().getCards()) {
+                                                            if (player1CardsList.contains(ca.getName())){
+                                                                if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){
+                                                                    sendResponse("Error Deleting user card1: " + ca.getName(), "500");
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                    Cards player2cards = new DBConnection().getCards(openBattle.getPlayer2().getCredentials().getUsername());
+                                                    ArrayList<String> player2CardsList = new ArrayList<String>();
+                                                    for(Card ca:player2cards.getCards()){
+                                                        player2CardsList.add(ca.getName());
+                                                    }
+                                                    if(player2cards.getCards() != null && !player2cards.getCards().isEmpty()) {
+                                                        for (Card ca : openBattle.getDeckPlayer2().getCards()) {
+                                                            if (player2CardsList.contains(ca.getName())){
+                                                                if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){
+                                                                    sendResponse("Error Deleting user card2: " + ca.getName(), "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 einladung konnte ned akzeptiert werden", "500"); //ERROR
+                                        }
+                                    }else{
+                                        sendResponse("GET User error", "500"); //ERROR
+                                    }
+                                } catch (SQLException throwables) {
+                                    throwables.printStackTrace();
+                                    sendResponse("GET User error", "500"); //ERROR
+                                }
+                            }
+                        }else {
+                            sendResponse("Nur "+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 {
+                    sendError("500");
+                }
+            }else {
+                sendError("401");
+            }
+        } else{
+            sendError("405");
+        }
+
     }
 
     /**
@@ -246,17 +500,21 @@ public class Response {
      * @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 = null;
-        DBConnection con = new DBConnection();
             try {
-            user = con.getUser(username);
+                user = new DBConnection().getUser(username);
+                if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){
+                    return true;
+                }else{
+                    return false;
+                }
             } catch (SQLException throwables) {
                 throwables.printStackTrace();
                 return false;
             }
-        if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){
+
-            return true;
         }else{
             return false;
         }
@@ -296,6 +554,23 @@ public class Response {
             }else{
                 sendError("500");
             }
+        }else if(this.url.startsWith("/deck")) {
+            List<String> deckIds = JsonHelper.jsonPayloadToList(this.payload);
+            if (deckIds != null){
+                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 {
+                        sendError("500");
+                    }
+                }else {
+                    sendError("500");
+                }
+            }else{
+                sendError("500");
+            }
         }
     }
 
@@ -307,7 +582,28 @@ public class Response {
      * @throws JsonProcessingException Fehler beim de-/serialisieren
      */
     private void deleteMethodes(){
-        if (this.url.startsWith("/messages")) {
+        if (this.url.startsWith("/tradings")) {
+            String tradeid = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Format in /tradings/{tradingid}: " + tradeid);
+            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 {
+                        sendError("500");
+                    }
+                }else{
+                    sendError("500");
+                }
+            }
 
         }
     }

src/test/java/CardsTest.java

@@ -52,12 +52,12 @@ public class CardsTest {
 
     @Test
     void test_contains() {
-        assertTrue(cards2.containsCard(card));
+        assertTrue(cards2.containsCard(card.getName()));
     }
 
     @Test
     void test_contains2() {
-        assertFalse(cards.containsCard(newCard));
+        assertFalse(cards.containsCard(newCard.getName()));
     }
 
     @Test

src/test/java/StoreTest.java

@@ -44,7 +44,7 @@ public class StoreTest {
         ElementTyp requiredElementType = ElementTyp.FIRE;
         double requiredMinDamage = 100;
         CardType requiredCardType = CardType.MONSTER;
-        tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType);
+        tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME");
 
     }
 /*

src/test/java/TradingDealTest.java

@@ -44,7 +44,7 @@ public class TradingDealTest {
         ElementTyp requiredElementType = ElementTyp.FIRE;
         double requiredMinDamage = 100;
         CardType requiredCardType = CardType.MONSTER;
-        tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType);
+        tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME");
     }
 
     /*