10 Commits
0.1.3 ... 0.2.1

17 changed files with 1556 additions and 251 deletions

View File

@ -1,4 +1,529 @@
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, counter = 0, counter2 = 0;
while(counter<maxroundcount) {
counter++;
counter2++;
if(counter2 < d1.size()-1 && counter2 < d2.size()-1){
counter2 = 0;
}
System.out.println("Runde: " + counter);
System.out.println("deck 1 size: " + d1.size() + " Deck 2 size: " + d2.size());
Card c1 = d1.get(counter2);
Card c2 = d2.get(counter2);
System.out.println("Card 1: " + c1.getElementTyp() + c1.getCardType() + "\nCard 2: " + c2.getElementTyp() + c2.getCardType());
if (d1.size() > 0 && d2.size() > 0 && counter<=maxroundcount) {
//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;
}
}

View File

@ -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);
if(tmpElement == null){
tmpElement = ElementTyp.UNDEF;
}
CardType tmpCard = stringToCardType(elementCardTyp);
CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
ElementTyp tmpElement = null;
if(tmpCard == null){
tmpCard = CardType.UNDEF;
}
//Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen
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
* @param elementTypeString elementType als String
* @return Passender Element Type oder null falls nicht gefunden
* Prüft ob die Karte gesperrt ist
* @return True wenn die Karte gesperrt ist
*/
private ElementTyp stringToElementType(String elementTypeString){
for (ElementTyp e : ElementTyp.values()) {
if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) {
return e;
}
}
return null;
public boolean isLocked() {
return locked;
}
/**
* 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
* Setzt die sperre der Karte
* @param locked True bedeuted gesperrt
*/
private CardType stringToCardType(String cardTypeString){
for (CardType me : CardType.values()) {
if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
return me;
}
}
return null;
public void setLocked(boolean locked) {
this.locked = locked;
}
/**

View File

@ -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
}

View File

@ -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);

View File

@ -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();
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());
if(!addUserCard(username, newCard.getName())){
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
* @param username Username des Users
* @return Cards Object, falls es null ist, war ein fehler
* Holt eine Card aus der DB, anhand der gegebenen Card Id
* @param id Id der Card die geholt werden soll
* @return Null bei error
*/
public Cards getCards(String username){
this.c = PostgresHelper.con();
String cardname = "";
Cards allCards = new Cards(new ArrayList<Card>());
ArrayList<String> cardnamenarray = new ArrayList<String>();
public Card getCardFromID(String id){
System.out.println(id);
Connection b = PostgresHelper.con();
Card toreturn = null;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';");
stmt = b.createStatement();
ResultSet rs = stmt.executeQuery("select * from card where NAME = \'" + id + "\';");
while (rs.next()) {
cardname = rs.getString("name");
cardnamenarray.add(cardname);
System.out.println("cardname = " + cardname);
int damage =rs.getInt("damage");
String elementtyp =rs.getString("elementtyp");
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
*

View File

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

View File

@ -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
* @param user at.reisinger.User des Deals
* Ein TradingDeal wird erstellt
* @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) {
//this.tradingUser = user;
public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) {
this.id = id;
this.cardToTrade = cardToTrade;
if(requiredElementType == null){
requiredElementType = ElementTyp.UNDEF;
}
if(requiredCardType == null) {
requiredCardType = CardType.UNDEF;
}
this.requiredElementType = requiredElementType;
this.requiredMinDamage = requiredMinDamage;
this.requiredCardType = requiredCardType;
this.username = username;
}
/**
* Holt den Trading at.reisinger.User
* @return at.reisinger.User der den Trade erstellt hat
public User getTradingUser() {
return this.tradingUser;
* Ein TradingDeal wird erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt
* @param id Id des Trading deals
* @param cardToTrade at.reisinger.Card die getauscht werden soll
* @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
* Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
*/
@JsonCreator
public TradingDeal(@JsonProperty("Id") String id, @JsonProperty("CardToTrade") Card cardToTrade, @JsonProperty("MinimumDamage") double requiredMinDamage, @JsonProperty("Type") String type, String username) {
this(id, cardToTrade, EnumHelper.stringToElementType(type), requiredMinDamage, EnumHelper.stringToCardType(type), username);
}
*/
/**
* Holt die ID des Trading deals
* @return Id des Trading Deals
*/
public String getId() {
return id;
}
/**
* 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;
}

View File

@ -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!");

View File

@ -0,0 +1,38 @@
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;
}
}

View File

@ -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
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;
}
return objToJson(user);
}
}

View File

@ -1,89 +0,0 @@
package at.reisinger.server.msg;
import at.reisinger.server.objects.Msg;
import java.util.HashMap;
/**
* Der Speicher der Nachrichten
* Mit hilfe einer HashMap werden die MsgId und die Msg selbst gespeichert
* @author Georg Reisinger
*/
public class MsgHandler {
private HashMap<Integer , String> msgHashMap;
private int lastID;
/**
* Erstellt den MsgHandler mit standart Test Messages
*/
public MsgHandler(){
msgHashMap = new HashMap<Integer, String>();
addMsg("Hallo");
addMsg("Wie");
addMsg("Geht");
addMsg("Es");
addMsg("Dir?");
}
/**
* Ermitelt die nächste freie Id
* @return Next ID
*/
private int nextId(){
return this.lastID + 1;
}
/**
* Msg hinzufügen
* @param msg Message Text
*/
public int addMsg(String msg){
int id = nextId();
msgHashMap.put(id, msg);
this.lastID = id;
return id;
}
/**
* Msg löschen
* @param id Message Id
*/
public String delMsg(int id){
return msgHashMap.remove(id);
}
/**
* Msg bearbeiten
* @param id Message Id
* @param msg Message Text
*/
public String editMsg(int id, String msg){
return msgHashMap.replace(id, msg);
}
/**
* Msg als Objekt holen
* @param id Message Id
* @return Message als Msg Objekt
*/
public Msg getMsg(int id){
return new Msg(id, msgHashMap.get(id));
}
/**
* Alle Nachrichten werden in den Format Key, Value besorgt
* bsp: key: 1 value: Nachricht
* @return Alle nachrichten in einem String
*/
public String getAllMsg(){
String returnStr = "";
// Print keys and values
for (Integer i : msgHashMap.keySet()) {
String item = "key: " + i + " value: " + msgHashMap.get(i) + "\n";
returnStr += item;
}
System.out.println(returnStr);
return returnStr;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}
/**

View File

@ -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,25 +235,23 @@ public class Response {
sendError("401");
}
}else if (this.url.startsWith("/packages")) {
if(login()) {
if (basicAuth("admin", "admin", this.authString)) {
ObjectMapper objectMapper = new ObjectMapper();
ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>() {
});
Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5);
if (!new DBConnection().addPackage(packageCards)) {
sendError("500");
} else {
String packageJson = JsonHelper.objToJson(packageCards);
if (packageJson != null) {
sendResponse(packageJson, "201");
} else {
sendError("500");
}
}
if (basicAuth("admin", "istrator", this.authString)) {
ObjectMapper objectMapper = new ObjectMapper();
ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>() {
});
Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5);
if (!new DBConnection().addPackage(packageCards)) {
sendError("500");
} else {
sendError("401");
String packageJson = JsonHelper.objToJson(packageCards);
if (packageJson != null) {
sendResponse(packageJson, "201");
} else {
sendError("500");
}
}
} else {
sendError("401");
}
}else if (this.url.startsWith("/transactions/packages")) {
if (login()) {
@ -237,8 +267,224 @@ 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
ArrayList<String> oldDeck1 = new ArrayList<String>();
for (Card ca: openBattle.getDeckPlayer1Init().getCards()){
oldDeck1.add(ca.getName());
}
ArrayList<String> oldDeck2 = new ArrayList<String>();
for (Card ca: openBattle.getDeckPlayer2Init().getCards()){
oldDeck2.add(ca.getName());
}
//DEL NEW CARDS IF EXIST
Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername());
for(Card ca:openBattle.getDeckPlayer1().getCards()){
oldDeck1.add(ca.getName());
}
if(player1cards.getCards() != null && !player1cards.getCards().isEmpty()) {
for (String ca : oldDeck1) {
if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca)){
sendResponse("Error Deleting user card1: " + ca, "500");
}
}
}
Cards player2cards = new DBConnection().getCards(openBattle.getPlayer2().getCredentials().getUsername());
for(Card ca:openBattle.getDeckPlayer2().getCards()){
oldDeck2.add(ca.getName());
}
if(player2cards.getCards() != null && !player2cards.getCards().isEmpty()) {
for (String ca : oldDeck2) {
if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca)){
sendResponse("Error Deleting user card2: " + ca, "500");
}
}
}
//ADD CARDS TO DECK
for(Card ca : openBattle.getDeckPlayer1().getCards()){
if(!new DBConnection().addUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){
sendResponse("Error adding card to user1: " + ca.getName(), "500");
}
}
for(Card ca : openBattle.getDeckPlayer2().getCards()){
if(!new DBConnection().addUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){
sendResponse("Error adding card to user2: " + ca.getName(), "500");
}
}
sendResponse("Du bist: #PLAYER 2\nBattle --> " + openBattle.getPlayer1().getName() + "(#PLAYER1) |vs| " + openBattle.getPlayer2().getName() + "(#PLAYER2)\nErgebnisse unter /score abrufbar", "200");
}
}else{
sendResponse("Battle Log konnte ned geschrieben werden", "500"); //ERROR
}
}else{
sendResponse("Battle 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 +492,21 @@ public class Response {
* @return True wenn login daten korrekt, sonst false
*/
private boolean login(){
String username = basicAuthGetUsername(this.authString);
User user = null;
DBConnection con = new DBConnection();
try {
user = con.getUser(username);
} catch (SQLException throwables) {
throwables.printStackTrace();
return false;
}
if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){
return true;
if(this.authString != null && !this.authString.isEmpty()){
String username = basicAuthGetUsername(this.authString);
User user = null;
try {
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;
}
}else{
return false;
}
@ -296,6 +546,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 +574,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");
}
}
}
}

View File

@ -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

View File

@ -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");
}
/*

View File

@ -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");
}
/*