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

/stats + /score + Performace Bugfixes + Removed unused + completed doc + Battle Bugfixes + other bugs

Browse Source
This commit is contained in:
Georg Reisinger 2021-01-02 15:15:47 +01:00
parent 93cbd8aae2
commit b4f0edafe3
36 changed files with 1064 additions and 1850 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -10,7 +10,7 @@
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# at.reisinger.Package Files #
# at.reisinger.obj.Package Files #
*.jar
*.war
*.nar

2
README.md
View File

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

213
src/main/java/at/reisinger/Card.java
View File

@ -1,213 +0,0 @@
package at.reisinger;
import at.reisinger.server.helper.EnumHelper;
import com.fasterxml.jackson.annotation.*;
/**
* Object einer at.reisinger.Card
*/
@JsonAutoDetect
public class Card {
@JsonProperty
private String name;
@JsonProperty
private double damage;
@JsonProperty
private ElementTyp elementTyp;
@JsonProperty
private CardType cardType;
@JsonProperty
private boolean locked;
/**
* Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften
* @param name Name der at.reisinger.Card
* @param damage Damage den die at.reisinger.Card macht
* @param elementTyp ElementType der at.reisinger.Card
* @param cardType at.reisinger.CardType der at.reisinger.Card
*/
public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) {
this.name = name;
this.damage = damage;
this.elementTyp = elementTyp;
this.cardType = cardType;
}
/**
* Erstellt eine neue Card mit, anhand des cardNamen werden der ElementType und der CardType automatisch bestimmt
* @param name Name der Card (ID)
* @param elementCardTyp ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
* Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
* @param damage Damage der Card
*/
@JsonCreator
public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
ElementTyp tmpElement = null;
if(tmpCard == null){
tmpCard = CardType.UNDEF;
}
//Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen
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;
}
/**
* Prüft ob die Karte gesperrt ist
* @return True wenn die Karte gesperrt ist
*/
public boolean isLocked() {
return locked;
}
/**
* Setzt die sperre der Karte
* @param locked True bedeuted gesperrt
*/
public void setLocked(boolean locked) {
this.locked = locked;
}
/**
* Holt den Namen der at.reisinger.Card
* @return Name der at.reisinger.Card
*/
@JsonGetter
public String getName() {
return this.name;
}
/**
* Holt den Damage der at.reisinger.Card
* @return Damage der at.reisinger.Card
*/
@JsonGetter
public double getDamage() {
return this.damage;
}
/**
* Holt den ElementType der at.reisinger.Card
* @return ElementType der at.reisinger.Card
*/
@JsonGetter
public ElementTyp getElementTyp() {
return this.elementTyp;
}
/**
* Holt den at.reisinger.CardType der at.reisinger.Card
* @return at.reisinger.CardType der at.reisinger.Card
*/
@JsonGetter
public CardType getCardType() {
return this.cardType;
}
/**
* Berechnet die Wirksamkeit gegen eine Andere card. Die at.reisinger.Card im Parameter wird angegriffen
* @param toCeck at.reisinger.Card gegen welche die Wirksamkeit geprüft werden soll
* @return Gibt die Wirksamkeit zurück
* @throws InternalError Wenn die Effectifeness von den 2 at.reisinger.Cards nicht berechnet werden kann
*/
@JsonGetter
public EffectivnessType getEffectivenessAgainst(Card toCeck) {
if(toCeck.getCardType() == CardType.MONSTER){
if(this.cardType == CardType.MONSTER){
return EffectivnessType.NOEFFECT;
}else if (this.cardType == CardType.SPELL){
}
}else if (toCeck.getCardType() == CardType.SPELL){
if ((toCeck.getElementTyp() == ElementTyp.FIRE && this.elementTyp == ElementTyp.WATER) || (toCeck.getElementTyp() == ElementTyp.NORMAL && this.elementTyp == ElementTyp.FIRE) || (toCeck.getElementTyp() == ElementTyp.WATER && this.elementTyp == ElementTyp.NORMAL)){
return EffectivnessType.EFFECTIVE;
}else if (this.elementTyp == ElementTyp.FIRE && toCeck.getElementTyp() == ElementTyp.WATER){
return EffectivnessType.NOTEFFECTIVE;
}else if ((toCeck.getElementTyp() == ElementTyp.NORMAL && this.cardType == CardType.MONSTER && this.elementTyp == ElementTyp.NORMAL)){
return EffectivnessType.NOEFFECT;
}
}
throw new InternalError("Konnte die Effectiveness von den at.reisinger.Cards nicht berechnen");
}
/**
* Setztden namen der at.reisinger.Card
* @param neuerName Name der at.reisinger.Card
*/
@JsonSetter
public void setName(String neuerName) {
this.name = neuerName;
}
/**
* Setzt den Damage der at.reisinger.Card
* @param damage Der Damage
*/
@JsonSetter
public void setDamage(int damage) {
this.damage = damage;
}
/**
* Setzt den ElementType der at.reisinger.Card
* @param elementTyp Der ElementType
*/
@JsonSetter
public void setElementType(ElementTyp elementTyp) {
this.elementTyp = elementTyp;
}
/**
* Testet ob die beiden Karten gleich sind
* @param card at.reisinger.Card die geprüft werden soll
* @return True wenn die Karten übereinstimmen
*/
public boolean equals(Card card){
if(card == null) return false;
if(this.name == card.getName() && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage()){
return true;
}else {
return false;
}
}
}

7
src/main/java/at/reisinger/EffectivnessType.java
View File

@ -1,7 +0,0 @@
package at.reisinger;
public enum EffectivnessType {
EFFECTIVE,
NOTEFFECTIVE,
NOEFFECT
}

7
src/main/java/at/reisinger/MonsterCard.java
View File

@ -1,7 +0,0 @@
package at.reisinger;
public class MonsterCard extends Card{
public MonsterCard(String name, double damage, ElementTyp elementTyp, CardType cardType) {
super(name, damage, elementTyp, cardType);
}
}

17
src/main/java/at/reisinger/NegativAmountException.java
View File

@ -1,17 +0,0 @@
package at.reisinger;
/**
* Wenn ein negativer wert eingegeben wird aber ein Positiver erwartet wird, dann kann diese Exception geworfen werden
*/
public class NegativAmountException extends Exception {
/**
* Aufruf des Constructors der Super class Exception
* @param message Fehler Nachrichgt
* @param cause Fehler Ursache
*/
public NegativAmountException(String message){
super(message);
}
}

7
src/main/java/at/reisinger/SpellCard.java
View File

@ -1,7 +0,0 @@
package at.reisinger;
public class SpellCard extends Card{
public SpellCard(String name, double damage, ElementTyp elementTyp, CardType cardType) {
super(name, damage, elementTyp, cardType);
}
}

50
src/main/java/at/reisinger/Stack.java
View File

@ -1,50 +0,0 @@
package at.reisinger;
/**
* Erweitert at.reisinger.Cards insofern, dass es im at.reisinger.Stack auch ein Deck gibt
*/
public class Stack extends Cards{
private Cards deck;
/**
* Erstellt einen neuen at.reisinger.Stack aus den at.reisinger.User at.reisinger.Cards und seinem Deck
* @param cards Alle at.reisinger.Cards des Users
* @param deck Sein Deck
*/
public Stack(Cards cards, Cards deck) {
super(cards.getCards());
this.deck = deck;
}
/**
* Fügt ein neues Deck in den at.reisinger.Stack ein
* @param newCards Gesamtes Deck
*/
public void addDeck(Cards newCards) {
this.deck = newCards;
}
/**
* Holt das gesamte Deck
* @return Gesamtes Deck
*/
public Cards getDeck() {
return this.deck;
}
/**
* Löscht eine at.reisinger.Card aus dem Deck
* @param toDel at.reisinger.Card zum löschen
*/
public void delDeck(Card toDel) {
this.deck.delCard(toDel);
}
// /**
// * Fügt dem deck eine neue at.reisinger.Card ein
// * @param toAdd Neue at.reisinger.Card
// */
// public void addDeckCard(at.reisinger.Card toAdd){
// this.deck.addCard(toAdd);
// }
}

15
src/main/java/at/reisinger/Store.java
View File

@ -1,15 +0,0 @@
package at.reisinger;
import java.util.ArrayList;
public interface Store {
//DBConnection db = new DBConnection();
void addTradingDeal(TradingDeal tradingDeal);
ArrayList<TradingDeal> getTradingDeals();
boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2);
ArrayList<TradingDeal> getPossibleTradingDeals(Card toTrade);
}

306
src/main/java/at/reisinger/User.java
View File

@ -1,306 +0,0 @@
package at.reisinger;
import com.fasterxml.jackson.annotation.*;
import java.util.ArrayList;
/**
* at.reisinger.User & at.reisinger.Store Logik
*/
@JsonAutoDetect
public class User{
@JsonProperty
private String name, nachname, email, bio, image;
/*
@JsonProperty
private Stack stack;
*/
//private DBConnection db;
@JsonProperty
private Credentials credentials;
@JsonProperty
private Coins coins;
/*
* Erstellt einen neuen at.reisinger.User
* @param credentials Zugangsdaten des Users
* @param name Name des Users
* @param nachname Nachname des Users
* @param email Email des Users
* @param stack Alle Karten des Users
* @param coins Alle Münzen des Users
@JsonCreator
public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Stack stack,@JsonProperty Coins coins) {
this.credentials = credentials;
this.name = name;
this.nachname = nachname;
this.email = email;
this.stack = stack;
this.coins = coins;
//this.db = new at.reisinger.DBConnection();
}
*/
@JsonCreator
public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins, @JsonProperty String bio, @JsonProperty String image) {
this.credentials = credentials;
this.name = name;
this.nachname = nachname;
this.email = email;
//this.stack = null;
this.coins = coins;
this.bio = bio;
this.image = image;
//this.db = new at.reisinger.DBConnection();
}
/**
* Holt die Bio vom User
* @return Bio des Users
*/
@JsonGetter
public String getBio() {
return bio;
}
/**
* Setzt die Bio vom User
* @param bio Bio des Users
*/
@JsonSetter
public void setBio(String bio) {
this.bio = bio;
}
/**
* Holt das image vom user
* @return Image vom user
*/
@JsonGetter
public String getImage() {
return image;
}
/**
* Setzt das image vom user
* @param image Image vom user
*/
@JsonSetter
public void setImage(String image) {
this.image = image;
}
/**
* Holt den at.reisinger.Stack des Users
* @return at.reisinger.Stack des Users
@JsonGetter
public Stack getStack() {
return stack;
}
/**
* Setzt den at.reisinger.Stack eines Users
* @param stack Der neue at.reisinger.Stack des Users
@JsonSetter
public void setStack(Stack stack) {
this.stack = stack;
}
/**
* Holt das DB Obj
* @return Das DB Obj
@JsonGetter
public DBConnection getDb() {
return new DBConnection();
}
/**
* Setzt ein neues DB Obj
* @param db Das neue DB Obj
@JsonSetter
public void setDb(DBConnection db) {
this.db = db;
}
*/
/**
* Holt die eindeutigen Logindaten des Users
* @return Eindeutige Logindaten
*/
@JsonGetter
public Credentials getCredentials() {
return credentials;
}
/**
* Setzt die eindeutigen Logindaten
* @param credentials Die neuen at.reisinger.Credentials des Users
*/
@JsonSetter
public void setCredentials(Credentials credentials) {
this.credentials = credentials;
}
/**
* Holt alle at.reisinger.Coins des Users
* @return at.reisinger.Coins des Users
*/
@JsonGetter
public Coins getCoins() {
return coins;
}
/**
* Setzt alle at.reisinger.Coins des Users
* @param coins Neue at.reisinger.Coins des Users
*/
@JsonSetter
public void setCoins(Coins coins) {
this.coins = coins;
}
/**
* Get Name of at.reisinger.User
* @return Name of at.reisinger.User
*/
@JsonGetter
public String getName() {
return this.name;
}
/**
* Get Nachname of at.reisinger.User
* @return Nachname of at.reisinger.User
*/
@JsonGetter
public String getNachname() {
return this.nachname;
}
/**
* Email of at.reisinger.User
* @return Email of at.reisinger.User
*/
@JsonGetter
public String getEmail() {
return this.email;
}
/**
* Setzt den Namen des Users
* @param name Neuer Name des Users
*/
@JsonSetter
public void setName(String name) {
this.name = name;
}
/**
* Setzt den Nachnamen
* @param nachname Neuer Nachname
*/
@JsonSetter
public void setNachname(String nachname) {
this.nachname = nachname;
}
/**
* Setzt die Email des Users
* @param email Neue Email des Users
*/
@JsonSetter
public void setEmail(String email) {
this.email = email;
}
//at.reisinger.Store Methoden
/**
* Kauft ein at.reisinger.Package
* @param mypackage at.reisinger.Package welches gekauft werden soll
* @return Alle Karten des neuen at.reisinger.Package
* @throws NegativAmountException Wenn ein negativer Preis im at.reisinger.Package gesetzt wird.
*/
public ArrayList<Card> buyPackage(Package mypackage) throws NegativAmountException {
//ArrayList<Package> availablePackages = new DBConnection().getAllPackages();
//availablePackages.removeIf(obj -> obj.equals(mypackage));
this.coins.removeCoin(mypackage.getPrice());
return mypackage.getCards();
}
/**
* Fügt dem at.reisinger.Store einen neuen Tradingdeal hinzu
* @param tradingDeal Der neue Tradingdeal
*
public void addTradingDeal(TradingDeal tradingDeal) {
new DBConnection().addTradingDeal(tradingDeal);
}
/**
* Holt alle verfügbaren Tradingdeals
* @return Alle verfügbaren Deals
*
public ArrayList<TradingDeal> getTradingDeals() {
return new DBConnection().getAllTradingDeals();
}
@Override
public boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2) {
return false;
}
/**
* Startet ein Trading zw 2 TradingDeals
* @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem at.reisinger.Stack entfernt
* @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem at.reisinger.Stack hinzugefügt
* @return True wenn erfolgreich, False wenn die Deals nicht zusammenpassen
public boolean doTrading(TradingDeal myTradingDeal, TradingDeal storeTradingDeal) {
if (storeTradingDeal.dealOk(myTradingDeal)){
stack.delCard(myTradingDeal.getCardToTrade());
stack.addCard(storeTradingDeal.getCardToTrade());
return true;
}
return false;
}
*/
/**
* Gibt alle Möglichen Trading Deals zurück
* @param toTrade Prüft nach diesem Deal
* @return
*
@Override
public ArrayList<TradingDeal> getPossibleTradingDeals(Card toTrade) {
ArrayList<TradingDeal> storeList = new DBConnection().getAllTradingDeals();
ArrayList<TradingDeal> possible = new ArrayList<TradingDeal>();
storeList.forEach(item -> {
if(item.cardOk(toTrade)){
System.out.println("ADDED ein item");
possible.add(item);
}
});
return possible;
}
*/
/**
* Checkt ob es sich um den selben at.reisinger.User handelt
* @param toCheck Mit diesem at.reisinger.User wird verglichen
* @return True wenn es der selbe at.reisinger.User ist
*/
public boolean equals(User toCheck){
if (toCheck.getCredentials().getUsername() == this.credentials.getUsername() && toCheck.getCredentials().getPasswort() == this.credentials.getPasswort()){
return true;
}else {
return false;
}
}
}

2
src/main/java/at/reisinger/CardType.java → src/main/java/at/reisinger/enums/CardType.java
View File

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

2
src/main/java/at/reisinger/ElementTyp.java → src/main/java/at/reisinger/enums/ElementTyp.java
View File

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

258
src/main/java/at/reisinger/Battle.java → src/main/java/at/reisinger/obj/Battle.java
View File

@ -1,45 +1,28 @@
package at.reisinger;
package at.reisinger.obj;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Objects;
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>();
private final User player1;
private User player2;
private int scorePlayer1;
private int scorePlayer2;
private final int id;
private Cards deckPlayer1;
private Cards deckPlayer2;
private final Cards deckPlayer1Init;
private Cards deckPlayer2Init;
private final ArrayList<String> log = new ArrayList<>();
/**
* Erstellt ein neues Battle
* @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
* @param id Id des Battles
* @param player1 Player 1 des Battles
* @param deckPlayer1 Deck vom Player 1 als json
*/
public Battle(int id, User player1, Cards deckPlayer1){
this.id = id;
@ -50,8 +33,6 @@ public class Battle {
this.deckPlayer2 = null;
this.deckPlayer1Init = deckPlayer1;
this.deckPlayer2Init = null;
this.spielfeldCardPlayer1 = null;
this.spielfeldCardPlayer2 = null;
}
/**
@ -59,9 +40,7 @@ public class Battle {
* @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
@ -77,41 +56,41 @@ public class Battle {
while(counter<maxroundcount) {
counter++;
counter2++;
if(counter2 < d1.size()-1 && counter2 < d2.size()-1){
if(counter2 < d1.size()-1 || counter2 < d2.size()-1){
counter2 = 0;
}
if (d1.size() > 0 && d2.size() > 0 && counter<=maxroundcount) {
System.out.println("Runde: " + counter);
System.out.println("deck 1 size: " + d1.size() + " Deck 2 size: " + d2.size());
System.out.println("deck 1 size: " + d1.size() + " Deck 2 size: " + d2.size() + " counter2: " + counter2);
Card c1 = d1.get(counter2);
Card c2 = d2.get(counter2);
System.out.println("Card 1: " + c1.getElementTyp() + c1.getCardType() + "\nCard 2: " + c2.getElementTyp() + c2.getCardType());
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")) {
if (!c1.getCardType().name().equalsIgnoreCase("SPELL") && !c2.getCardType().name().equalsIgnoreCase("SPELL")) {
System.out.println("Same Monster");
//Check ob eine der beiden Carten ein Dragon ist
if ((c1.getCardType().name().toUpperCase().equals("DRANGON") && !c2.getCardType().name().toUpperCase().equals("DRANGON") || (!c1.getCardType().name().toUpperCase().equals("DRANGON") && c2.getCardType().name().toUpperCase().equals("DRANGON")))) {
if ((c1.getCardType().name().equalsIgnoreCase("DRANGON") && !c2.getCardType().name().equalsIgnoreCase("DRANGON") || (!c1.getCardType().name().equalsIgnoreCase("DRANGON") && c2.getCardType().name().equalsIgnoreCase("DRANGON")))) {
//Eine der Karten is Dragon
System.out.println("Eine ist ein dragon");
Card dragon = null;
int dragonOwner = 0;
if (c1.getCardType().name().toUpperCase().equals("DRAGON")) {
Card dragon;
int dragonOwner;
if (c1.getCardType().name().equalsIgnoreCase("DRAGON")) {
dragon = c1;
dragonOwner = 1;
} else if (c2.getCardType().name().toUpperCase().equals("DRAGON")) {
} else if (c2.getCardType().name().equalsIgnoreCase("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")))) {
if ((c1.getCardType().name().equalsIgnoreCase("GOBLIN") && !c2.getCardType().name().equalsIgnoreCase("GOBLIN") || (!c1.getCardType().name().equalsIgnoreCase("GOBLIN") && c2.getCardType().name().equalsIgnoreCase("GOBLIN")))) {
//Eine der Karten ist Goblin
System.out.println("Andere ist ein goblin");
Card goblin = null;
if (c1.getCardType().name().toUpperCase().equals("GOBLIN")) {
Card goblin;
if (c1.getCardType().name().equalsIgnoreCase("GOBLIN")) {
goblin = c1;
} else if (c2.getCardType().name().toUpperCase().equals("GOBLIN")) {
} else if (c2.getCardType().name().equalsIgnoreCase("GOBLIN")) {
goblin = c2;
} else {
System.out.println("KEIN GOBLIN GEFUNDEN");
@ -124,7 +103,7 @@ public class Battle {
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
} else if (dragonOwner == 2) {
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer1 -= 5;
@ -134,13 +113,13 @@ public class Battle {
} 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")))) {
} else if ((c1.getCardType().name().equalsIgnoreCase("ELF") && c1.getElementTyp().name().equalsIgnoreCase("FIRE") && !c2.getCardType().name().equalsIgnoreCase("ELF") || (!c1.getCardType().name().equalsIgnoreCase("ELF") && c2.getElementTyp().name().equalsIgnoreCase("FIRE") && c2.getCardType().name().equalsIgnoreCase("ELF")))) {
//Eine der Karten ist der Fire Elf die andere Karte ist der drache
System.out.println("Andere ist ein elf");
Card fireelf = null;
Card fireelf;
if (dragonOwner == 1) {
fireelf = c2;
} else if (dragonOwner == 2) {
} else {
fireelf = c1;
}
@ -151,7 +130,7 @@ public class Battle {
d1.remove(c1);
this.scorePlayer2 += 3;
this.scorePlayer1 -= 5;
} else if (dragonOwner == 2) {
} else {
d1.add(c2);
d2.remove(c2);
this.scorePlayer2 -= 5;
@ -177,27 +156,27 @@ public class Battle {
}
//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")))) {
} else if ((c1.getCardType().name().equalsIgnoreCase("WIZZARD") && c2.getCardType().name().equalsIgnoreCase("ORK") || (c2.getCardType().name().equalsIgnoreCase("WIZZARD") && c1.getCardType().name().equalsIgnoreCase("ORK")))) {
System.out.println("Eine wizzard Andere ist ein ork");
Card wizzard = null;
Card ork = null;
int wizzardOwner = 0;
if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) {
if (c1.getCardType().name().equalsIgnoreCase("WIZZARD")) {
wizzardOwner = 1;
wizzard = c1;
ork = c2;
} else if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) {
} else if (c2.getCardType().name().equalsIgnoreCase("WIZZARD")) {
wizzardOwner = 2;
wizzard = c2;
ork = c1;
}
if (wizzard.getDamage() > ork.getDamage()) {
if (wizzard != null && wizzard.getDamage() > ork.getDamage()) {
if (wizzardOwner == 1) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
} else if (wizzardOwner == 2) {
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
@ -227,51 +206,51 @@ public class Battle {
} else {//PURE SPELL & mixed
double damagePlayer1 = -1, damagePlayer2 = -1;
if (c1.getCardType().name().toUpperCase().equals("KNIGHT") || c2.getCardType().name().toUpperCase().equals("KNIGHT")) {
if (c1.getCardType().name().equalsIgnoreCase("KNIGHT") || c2.getCardType().name().equalsIgnoreCase("KNIGHT")) {
//Mixed mit "Spezialeffekt" KNIGHT
System.out.println("Spell und knight");
Card knight = null, other = null;
int knightOwner = 0;
if (c1.getCardType().name().toUpperCase().equals("KNIGHT")) {
if (c1.getCardType().name().equalsIgnoreCase("KNIGHT")) {
knight = c1;
other = c2;
knightOwner = 1;
} else if (c2.getCardType().name().toUpperCase().equals("KNIGHT")) {
} else if (c2.getCardType().name().equalsIgnoreCase("KNIGHT")) {
knight = c2;
other = c1;
knightOwner = 2;
}
double damageKnight = -1, damageOther = -1;
if (other.getElementTyp().name().toUpperCase().equals("WATER")) {
if (Objects.requireNonNull(other).getElementTyp().name().equalsIgnoreCase("WATER")) {
//tot
damageKnight = 0;
damageOther = other.getDamage();
} else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("REGULAR")) {
} else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("REGULAR")) {
//not effective
damageKnight = knight.getDamage() / 2;
//effective
damageOther = other.getDamage() * 2;
} else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("FIRE")) {
} else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("FIRE")) {
//no effect
damageKnight = knight.getDamage();
//no effect
damageOther = other.getDamage();
} else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("WATER")) {
} else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("WATER")) {
//effective
damageKnight = knight.getDamage() * 2;
//not effective
damageOther = other.getDamage() / 2;
} else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("REGULAR")) {
} else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("REGULAR")) {
//no effect
damageKnight = knight.getDamage();
//no effect
damageOther = other.getDamage();
} else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("FIRE")) {
} else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("FIRE")) {
//effective
damageKnight = knight.getDamage() * 2;
//not effective
damageOther = other.getDamage() / 2;
} else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("WATER")) {
} else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("WATER")) {
//not effective
damageKnight = knight.getDamage() / 2;
//effective
@ -284,7 +263,7 @@ public class Battle {
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) {
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
@ -298,7 +277,7 @@ public class Battle {
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) {
} else {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
@ -306,15 +285,15 @@ public class Battle {
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")) {
} else if (c1.getCardType().name().equalsIgnoreCase("KRAKEN") || c2.getCardType().name().equalsIgnoreCase("KRAKEN")) {
//Mixed mit "Spezialeffekt" KRAKEN
if (c1.getCardType().name().toUpperCase().equals("KRAKEN")) {
if (c1.getCardType().name().equalsIgnoreCase("KRAKEN")) {
d1.add(c2);
d2.remove(c2);
this.scorePlayer1 += 3;
this.scorePlayer2 -= 5;
log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
} else if (c2.getCardType().name().toUpperCase().equals("KRAKEN")) {
} else if (c2.getCardType().name().equalsIgnoreCase("KRAKEN")) {
d2.add(c1);
d1.remove(c1);
this.scorePlayer2 += 3;
@ -325,74 +304,106 @@ public class Battle {
////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")) {
switch (c1.getElementTyp().name().toUpperCase()) {
case "FIRE":
switch (c2.getElementTyp().name().toUpperCase()) {
case "REGULAR":
//effective
damagePlayer1 = c1.getDamage() * 2;
} else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
break;
case "WATER":
//not effective
damagePlayer1 = c1.getDamage() / 2;
} else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
break;
case "FIRE":
//no effect
damagePlayer1 = c1.getDamage();
break;
}
} else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
break;
case "WATER":
switch (c2.getElementTyp().name().toUpperCase()) {
case "FIRE":
//effective
damagePlayer1 = c1.getDamage() * 2;
} else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
break;
case "WATER":
//no effect
damagePlayer1 = c1.getDamage();
} else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
break;
case "REGULAR":
//not effective
damagePlayer1 = c1.getDamage() / 2;
break;
}
} else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
break;
case "REGULAR":
switch (c2.getElementTyp().name().toUpperCase()) {
case "WATER":
//effective
damagePlayer1 = c1.getDamage() * 2;
} else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
break;
case "FIRE":
//not effective
damagePlayer1 = c1.getDamage() / 2;
} else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
break;
case "REGULAR":
//no effect
damagePlayer1 = c1.getDamage();
break;
}
break;
}
//P2 damage
if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
switch (c2.getElementTyp().name().toUpperCase()) {
case "FIRE":
switch (c1.getElementTyp().name().toUpperCase()) {
case "REGULAR":
//effective
damagePlayer2 = c2.getDamage() * 2;
} else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
break;
case "WATER":
//not effective
damagePlayer2 = c2.getDamage() / 2;
} else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
break;
case "FIRE":
//no effect
damagePlayer2 = c2.getDamage();
break;
}
} else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
break;
case "WATER":
switch (c1.getElementTyp().name().toUpperCase()) {
case "FIRE":
//effective
damagePlayer2 = c2.getDamage() * 2;
} else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
break;
case "WATER":
//no effect
damagePlayer2 = c2.getDamage();
} else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
break;
case "REGULAR":
//not effective
damagePlayer2 = c2.getDamage() / 2;
break;
}
} else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
break;
case "REGULAR":
switch (c1.getElementTyp().name().toUpperCase()) {
case "WATER":
//effective
damagePlayer2 = c2.getDamage() * 2;
} else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
break;
case "FIRE":
//not effective
damagePlayer2 = c2.getDamage() / 2;
} else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
break;
case "REGULAR":
//no effect
damagePlayer2 = c2.getDamage();
break;
}
break;
}
if (damagePlayer1 > -1 && damagePlayer2 > -1) {
@ -415,6 +426,8 @@ public class Battle {
}
}
}
}else {
return true;
}
}
this.deckPlayer1 = new Cards(d1);
@ -426,19 +439,6 @@ public class Battle {
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;
}
@ -448,18 +448,10 @@ public class Battle {
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;
}
@ -472,27 +464,15 @@ public class Battle {
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;
@ -503,22 +483,6 @@ public class Battle {
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;
}

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

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

45
src/main/java/at/reisinger/Cards.java → src/main/java/at/reisinger/obj/Cards.java
View File

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

19
src/main/java/at/reisinger/Coins.java → src/main/java/at/reisinger/obj/Coins.java
View File

@ -1,4 +1,4 @@
package at.reisinger;
package at.reisinger.obj;
/**
* Alle coins eines Users
@ -25,12 +25,9 @@ public class Coins {
/**
* Fügt münzen hinzu
* @param coins Münzen die hinzugefügt werden -> Positiv
* @throws NegativAmountException Wenn negative münzen hinzugefüght werden
*/
public void addCoin(int coins) throws NegativAmountException{
if(coins < 0) {
throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden");
}else {
public void addCoin(int coins){
if(coins > 0) {
this.amount += coins;
}
}
@ -39,11 +36,10 @@ public class Coins {
* Entfernt münzen
* @param coins Münzen die entfernt werden sollen, muss positiv sein
* @return True wenn erfolgreich
* @throws NegativAmountException Wenn ein negativer betrag abgezogen werden soll
*/
public boolean removeCoin(int coins) throws NegativAmountException{
public boolean removeCoin(int coins){
if(coins < 0) {
throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden");
return false;
}else {
this.amount -= coins;
return true;
@ -54,11 +50,10 @@ public class Coins {
* Ändert den Absoluten Coin amount
* @param coins Neue Coin anzahl, muss positiv sein
* @return true wenn erfolgreich
* @throws NegativAmountException Wenn ein negativer wert eingegeben wird
*/
public boolean changeCoinAmmount(int coins) throws NegativAmountException{
public boolean changeCoinAmmount(int coins){
if(coins < 0) {
throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden");
return false;
}else {
this.amount = coins;
return true;

24
src/main/java/at/reisinger/Credentials.java → src/main/java/at/reisinger/obj/Credentials.java
View File

@ -1,13 +1,14 @@
package at.reisinger;
package at.reisinger.obj;
/**
* at.reisinger.User Login Daten
* at.reisinger.obj.User Login Daten
*/
public class Credentials {
private String passwort, username;
private final String passwort;
private final String username;
/**
* Startet einen neuen at.reisinger.User mit folgenden Daten
* Startet einen neuen at.reisinger.obj.User mit folgenden Daten
* @param username Diesem Usernamen
* @param passwort Diesem Passwort
*/
@ -24,14 +25,6 @@ public class Credentials {
return passwort;
}
// /**
// * Setzt das at.reisinger.User Passwort
// * @param passwort Neues Passwort
// */
// public void setPasswort(String passwort) {
// this.passwort = passwort;
// }
/**
* Holt den Usernamen des Users
* @return Username
@ -40,11 +33,4 @@ public class Credentials {
return username;
}
// /**
// * Setzt einen neuen Usernamen
// * @param username Neuer Username
// */
// public void setUsername(String username) {
// this.username = username;
// }
}

10
src/main/java/at/reisinger/Package.java → src/main/java/at/reisinger/obj/Package.java
View File

@ -1,20 +1,20 @@
package at.reisinger;
package at.reisinger.obj;
import com.fasterxml.jackson.annotation.*;
/**
* at.reisinger.Package besteht aus 4 Karten. Ist eine Erweiterung der at.reisinger.Cards, zeigt für 4 at.reisinger.Cards den Preis und einen Packagenamen an
* at.reisinger.obj.Package besteht aus 4 Karten. Ist eine Erweiterung der at.reisinger.obj.Cards, zeigt für 4 at.reisinger.obj.Cards den Preis und einen Packagenamen an
*/
@JsonAutoDetect
public class Package extends Cards{
@JsonProperty
private String name;
@JsonProperty
private int price;
private final int price;
/**
* Erstellt ein neues at.reisinger.Package mit den gegebenen Stats
* @param stack at.reisinger.Cards des Packages
* Erstellt ein neues at.reisinger.obj.Package mit den gegebenen Stats
* @param stack at.reisinger.obj.Cards des Packages
* @param name Name des Packages
* @param price Price des Packages
*/

82
src/main/java/at/reisinger/TradingDeal.java → src/main/java/at/reisinger/obj/TradingDeal.java
View File

@ -1,5 +1,7 @@
package at.reisinger;
package at.reisinger.obj;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
import at.reisinger.server.helper.EnumHelper;
import com.fasterxml.jackson.annotation.*;
@ -9,7 +11,9 @@ import com.fasterxml.jackson.annotation.*;
@JsonAutoDetect
public class TradingDeal {
@JsonProperty
private String id, username;
private final String id;
@JsonProperty
private final String username;
@JsonProperty
private Card cardToTrade;
@JsonProperty
@ -22,10 +26,10 @@ public class TradingDeal {
/**
* Ein TradingDeal wird erstellt
* @param id Id des Trading deals
* @param cardToTrade at.reisinger.Card die getauscht werden soll
* @param cardToTrade at.reisinger.obj.Card die getauscht werden soll
* @param requiredElementType Req ElementType für den Tausch
* @param requiredMinDamage Req min damage für den Tausch
* @param requiredCardType Req at.reisinger.Card Type für den Tausch
* @param requiredCardType Req at.reisinger.obj.Card Type für den Tausch
*/
public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) {
this.id = id;
@ -45,7 +49,7 @@ public class TradingDeal {
/**
* 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 cardToTrade at.reisinger.obj.Card die getauscht werden soll
* @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
* Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
*/
@ -62,14 +66,6 @@ public class TradingDeal {
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
@ -80,18 +76,8 @@ public class TradingDeal {
}
/**
* 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
* at.reisinger.obj.Card die getraded werden soll
* @return at.reisinger.obj.Card die getradet werden soll
*/
@JsonGetter
public Card getCardToTrade() {
@ -118,24 +104,16 @@ public class TradingDeal {
/**
* Hole req cardtype
* @return Req at.reisinger.CardType
* @return Req at.reisinger.enums.CardType
*/
@JsonGetter
public CardType getRequiredCardType() {
return this.requiredCardType;
}
/**
* Setzt den at.reisinger.User des Trades
* @param tradingUser at.reisinger.User der Traded
public void setTradingUser(User tradingUser) {
this.tradingUser = tradingUser;
}
*/
/**
* Setzt die Karte die Getradet werden soll
* @param cardToTrade at.reisinger.Card zum tauschen
* @param cardToTrade at.reisinger.obj.Card zum tauschen
*/
@JsonSetter
public void setCardToTrade(Card cardToTrade) {
@ -162,7 +140,7 @@ public class TradingDeal {
/**
* Setzt req cardType
* @param requiredCardType Der Req at.reisinger.CardType
* @param requiredCardType Der Req at.reisinger.enums.CardType
*/
@JsonSetter
public void setRequiredCardType(CardType requiredCardType) {
@ -170,37 +148,11 @@ public class TradingDeal {
}
/**
* Vom deal im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen
* @param checkDeal Von diesem Deal wird die CardToTrade geprüft
* @return True wenn der Deal passt
*/
public boolean dealOk(TradingDeal checkDeal){
return this.cardOk(checkDeal.getCardToTrade());
}
/**
* Von der at.reisinger.Card im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen
* @param checkCard at.reisinger.Card die mit dem Deal verglichen wird
* Von der at.reisinger.obj.Card im Parameter wird die at.reisinger.obj.Card mit den Requirements von THIS verglichen
* @param checkCard at.reisinger.obj.Card die mit dem Deal verglichen wird
* @return True wenn der Deal passt
*/
public boolean cardOk(Card checkCard){
System.out.println(checkCard.getCardType().equals(this.requiredCardType));
System.out.println(checkCard.getCardType().toString());
System.out.println(this.requiredCardType.toString());
System.out.println(" ");
System.out.println(checkCard.getElementTyp().equals(this.requiredElementType));
System.out.println(checkCard.getElementTyp().toString());
System.out.println(this.requiredElementType);
System.out.println(" ");
System.out.println(checkCard.getDamage() >= this.requiredMinDamage);
System.out.println(checkCard.getDamage());
System.out.println(this.requiredMinDamage);
if(checkCard.getCardType().equals(this.requiredCardType) && checkCard.getElementTyp().equals(this.requiredElementType) && checkCard.getDamage() >= this.requiredMinDamage){
System.out.println("Da simma true");
return true;
}else {
System.out.println("da simma false");
return false;
}
return checkCard.getCardType().equals(this.requiredCardType) && (checkCard.getElementTyp().equals(this.requiredElementType) || this.requiredElementType.name().equalsIgnoreCase("undef")) && checkCard.getDamage() >= this.requiredMinDamage;
}
}

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

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

397
src/main/java/at/reisinger/DBConnection.java → src/main/java/at/reisinger/server/DBConnection.java
View File

@ -1,5 +1,7 @@
package at.reisinger;
package at.reisinger.server;
import at.reisinger.obj.*;
import at.reisinger.obj.Package;
import at.reisinger.server.helper.JsonHelper;
import at.reisinger.server.helper.PostgresHelper;
@ -14,8 +16,6 @@ import java.util.Map;
* Die "Datenbank" sind hier nur beispieldaten.
*/
public class DBConnection {
//private ArrayList<TradingDeal> tradingDeals;
//private ArrayList<Package> packages;
private Connection c;
private Statement stmt;
@ -25,7 +25,7 @@ public class DBConnection {
* Verbindungsaufbau zu einer DB
*/
public DBConnection() {
this.c = PostgresHelper.con();
this.c = null;
}
/**
@ -41,10 +41,118 @@ public class DBConnection {
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.executeUpdate("create table IF NOT EXISTS battle_log(id int not null constraint battle_log_pk primary key, playerone text not null,playertwo text not null,playeronescore text not null,playertwoscore text not null,log varchar(10485760));");
PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS battle_log_id_uindex on battle_log (id);", "Battle_lgo Table created");
}
/**
* Holt alle BattleIds an denen der User beteiligt war
* @param username User der zu prüfen ist
* @return Null bei fehler, sonst eine List aus den IDs
*/
public ArrayList<String> getAllBattleIdUser(String username){
this.c = PostgresHelper.con();
int id;
ArrayList<String> battleIds = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select id from battle_log where playerone = '" + username + "' or playertwo = '" + username + "';");
while (rs.next()) {
id = rs.getInt("id");
if (id > 0) {
System.out.println("BATTLE ID: " + id);
battleIds.add(id + "");
}else {
return null;
}
}
rs.close();
stmt.close();
this.c.close();
return battleIds;
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
}
/**
* Holt die Letzte BattleId eines users
* @param username Userid die geprüft werden soll
* @return -1 bei error, sonst die letzte battleid des users
*/
public int getLastBattleIdUser(String username){
this.c = PostgresHelper.con();
int id;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select max(id) from battle_log where playerone = '" + username + "' or playertwo = '" + username + "';");
while (rs.next()) {
id = rs.getInt("max");
System.out.println("select max(id) from battle_log where playerone = '" + username + "' or playerone = '" + username + "';");
System.out.println("PREEEE IF ID: " + id);
if (id > 0) {
System.out.println("LAST BATTLE ID: " + id);
return id;
}else {
return -1;
}
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return -1;
}
return -1;
}
/**
* Holt das Battellog eines Bestimmten Battles
* @param battleId Id des battles
* @return Eine Map mit namen von player1 und player2, player1Score und player2Score und log
*/
public Map<String, String> getBattleLog(String battleId){
this.c = PostgresHelper.con();
String playerone, playertwo, score1, score2, log;
int id;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from battle_log where id = " + battleId + ";");
while (rs.next()) {
id = rs.getInt("id");
playerone = rs.getString("playerone");
playertwo = rs.getString("playertwo");
score1 = rs.getString("playeronescore");
score2 = rs.getString("playertwoscore");
log = rs.getString("log");
if (id > 0 && !playerone.isEmpty() && !playertwo.isEmpty() && !score1.isEmpty() && !score2.isEmpty() && !log.isEmpty()){
Map<String, String> map = new java.util.HashMap<>(Collections.emptyMap());
map.put("playerone", playerone);
map.put("playertwo", playertwo);
map.put("playeronescore", score1);
map.put("playertwoscore", score2);
map.put("log", log);
map.put("id", id+"");
return map;
}else{
System.out.println("GET BATTLE LOG WAS EMPTY");
return null;
}
}
rs.close();
stmt.close();
this.c.close();
} catch (Exception e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
return null;
}
/**
* Fügt der Battle tabelle ein battle hinzu
* @return True bei erfolg, sonst false
@ -56,8 +164,7 @@ public class DBConnection {
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");
return PostgresHelper.executeUpdateMessage("insert into battle (usernamecreator, deckcreator) VALUES ('" + usernamecreator + "','" + deckJson + "');", "Battle created");
}else {
return false;
}
@ -75,16 +182,14 @@ public class DBConnection {
*/
public Battle getOpenBattle(){
this.c = PostgresHelper.con();
ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
int battleid = 0;
String usernamecreator = "", deckcreator = "";
int battleid;
String usernamecreator;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from battle limit 1;");
while (rs.next()) {
battleid = rs.getInt("battleid");
usernamecreator = rs.getString("usernamecreator");
deckcreator = rs.getString("deckcreator");
User player1 = new DBConnection().getUser(usernamecreator);
if(player1 != null){
ArrayList<String> deckPlayer1Arr = new DBConnection().getDeck(usernamecreator);
@ -122,7 +227,7 @@ public class DBConnection {
* @return true bei erfolg sonst false
*/
public boolean delBattleEinladung(String battleid){
return PostgresHelper.executeUpdateMessage("delete from battle where battleid = \'"+ battleid +"\';", "Battle req deleted");
return PostgresHelper.executeUpdateMessage("delete from battle where battleid = '" + battleid + "';", "Battle req deleted");
}
@ -135,91 +240,12 @@ public class DBConnection {
* @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+"\');");
public boolean addBattleLog(String id, String playerone, String playertwo, String playeronescore, String playertwoscore, String log){
return PostgresHelper.executeUpdate("insert into battle_log (id, playerone, playertwo, playeronescore, playertwoscore, log) VALUES ("+id+ ",'" +playerone+ "','" +playertwo+ "','" +playeronescore+ "','" +playertwoscore+ "','" +log+ "');");
}
/**
* 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
@ -228,7 +254,7 @@ public class DBConnection {
* @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 + "\';");
return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = '" + name + "';");
}
@ -240,17 +266,15 @@ public class DBConnection {
*/
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 + "\';");
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;
}
@ -260,7 +284,7 @@ public class DBConnection {
* @return True bei erfolg, sonst false
*/
public boolean deleteTradingDeal(String id){
return PostgresHelper.executeUpdate("delete from trading where id = \'" + id + "\';");
return PostgresHelper.executeUpdate("delete from trading where id = '" + id + "';");
}
/**
@ -274,11 +298,7 @@ public class DBConnection {
* @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;
}
return PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES ('" + username + "','" + id + "','" + cardtotrade + "','" + mindamage + "','" + reqcardtype + "','" + reqelement + "');");
}
/**
@ -287,7 +307,7 @@ public class DBConnection {
*/
public ArrayList<TradingDeal> getAllTradingDeals(){
this.c = PostgresHelper.con();
ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
ArrayList<TradingDeal> tradingDeals = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from trading;");
@ -304,12 +324,7 @@ public class DBConnection {
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;
}
@ -323,7 +338,6 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
System.out.println("Trading Deals pulled successfully");
return tradingDeals;
}
@ -344,27 +358,34 @@ public class DBConnection {
return false;
}
}
Cards allCards = getCards(username);
Cards deckCards = new Cards(new ArrayList<>());
int count = 0;
if(allCards != null && deck.size() == 4){
for (String st : deck) {
for (Card ca: allCards.getCards()) {
if(ca.getName().equals(st) && count < 4){
if(deckCards.getCards().size() == 0){
if (!delDeck(username)){
return false;
}
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")){
if(deckCards.getCards().size() == 4){
int c = 0;
for(Card cardtmp : deckCards.getCards()){
c++;
if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES ('" +username+ "', '" +cardtmp.getName()+ "');", "Card #"+c+" added to Deck")){
return false;
}
}
return true;
}
}
}
count++;
}
return true;
return false;
}
return false;
}
@ -376,16 +397,14 @@ public class DBConnection {
*/
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>();
String cardname;
ArrayList<String> cardnamenarray = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from user_deck where username = \'" + username + "\';");
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();
@ -394,7 +413,6 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
System.out.println("Deck names pulled successfully");
return cardnamenarray;
}
@ -404,7 +422,7 @@ public class DBConnection {
* @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");
return PostgresHelper.executeUpdateMessage("delete from user_deck where username = '" + username + "';", "User Deck: " + username + ", deleted");
}
@ -419,7 +437,9 @@ public class DBConnection {
if (!(coins - 5 >= 0)) {
return null;
}
updateCoins(coins - 5, username);
if(!updateCoins(coins - 5, username)){
return null;
}
this.c = PostgresHelper.con();
String id = "";
@ -436,18 +456,14 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
System.out.println("Package selected successfully");
this.c = PostgresHelper.con();
String packagename = "", cardname = "", elementtyp = "", cardtype = "";
int zeilennummer = 0, damage = 0;
Cards cards = new Cards(new ArrayList<Card>());
String packagename = "", cardname, elementtyp, cardtype;
int damage;
Cards cards = new Cards(new ArrayList<>());
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select i as zeilennummer, package.\"ID\" as id, package.name as packagename, c.name as cardname, c.DAMAGE as damage, c.ELEMENTTYP as elementtyp, c.CARDTYPE as cardtype from package join card c on c.name = package.name where \"ID\" = \'" + id + "\';");
int count = 0;
ResultSet rs = stmt.executeQuery("select i as zeilennummer, package.\"ID\" as id, package.name as packagename, c.name as cardname, c.DAMAGE as damage, c.ELEMENTTYP as elementtyp, c.CARDTYPE as cardtype from package join card c on c.name = package.name where \"ID\" = '" + id + "';");
while (rs.next()) {
System.out.println(count++);
zeilennummer = rs.getInt("zeilennummer");
id = rs.getString("id");
packagename = rs.getString("packagename");
cardname = rs.getString("cardname");
@ -467,11 +483,12 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
System.out.println("Package pulled successfully");
deletePackage(id);
if(!deletePackage(id)){
return null;
}
if (cards.getCards().size() != 0 && cards != null) {
return new Package(cards, packagename, 5);
if (cards.getCards().size() != 0) {
return new at.reisinger.obj.Package(cards, packagename, 5);
} else {
return null;
}
@ -484,7 +501,7 @@ public class DBConnection {
* @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+"\';");
return PostgresHelper.executeUpdate("delete from user_cards where username = '" +username+ "' and name = '" +cardname+ "';");
}
/**
@ -497,7 +514,7 @@ public class DBConnection {
Connection b = PostgresHelper.con();
try {
stmt = b.createStatement();
String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + cardName + "\', \'false\');";
String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( '" + username + "','" + cardName + "', 'false');";
stmt.executeUpdate(sql);
stmt.close();
b.close();
@ -505,7 +522,6 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return false;
}
System.out.println("User got Card successfully");
return true;
}
/**
@ -515,7 +531,7 @@ public class DBConnection {
* @return True bei erfolg, sonst false
*/
public boolean deletePackage(String name) {
return PostgresHelper.executeUpdateMessage("DELETE FROM package WHERE \"ID\" = \'" + name + "\';", "Package deleted successfully");
return PostgresHelper.executeUpdateMessage("DELETE FROM package WHERE \"ID\" = '" + name + "';", "Package deleted successfully");
}
@ -526,7 +542,7 @@ public class DBConnection {
* @return True bei erfolg, sonst false
*/
public boolean updateCoins(int coins, String username) {
return PostgresHelper.executeUpdateMessage("UPDATE users SET coins = " + coins + " WHERE username = \'" + username + "\';", "Coins Updated");
return PostgresHelper.executeUpdateMessage("UPDATE users SET coins = " + coins + " WHERE username = '" + username + "';", "Coins Updated");
}
/**
@ -535,12 +551,11 @@ public class DBConnection {
* @return Anzahl der Coins, -1 ist error
*/
public int checkCoins(String username) {
System.out.println("Check coin start");
this.c = PostgresHelper.con();
int coins = 0;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("Select coins from users where username = \'" + username + "\';");
ResultSet rs = stmt.executeQuery("Select coins from users where username = '" + username + "';");
while (rs.next()) {
coins = rs.getInt("coins");
}
@ -548,11 +563,9 @@ public class DBConnection {
stmt.close();
this.c.close();
} catch (Exception e) {
System.out.println("check soin error");
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return -1;
}
System.out.println("\nCoins: " + coins);
return coins;
}
@ -567,7 +580,7 @@ public class DBConnection {
int count = 0;
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select count(*) from card where name = \'" + name + "\';");
ResultSet rs = stmt.executeQuery("select count(*) from card where name = '" + name + "';");
while (rs.next()) {
count = rs.getInt("count");
}
@ -578,11 +591,7 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
System.exit(0);
}
if (count == 1) {
return true;
} else {
return false;
}
return count == 1;
}
/**
@ -592,7 +601,7 @@ public class DBConnection {
* @return true bei erfolg, false bei error
*/
public boolean addCard(Card card) {
return PostgresHelper.executeUpdateMessage("insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values (\'" + card.getName() + "\',\'" + card.getDamage() + "\',\'" + card.getElementTyp().name() + "\',\'" + card.getCardType().name() + "\')", "Card added");
return PostgresHelper.executeUpdateMessage("insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values ('" + card.getName() + "','" + card.getDamage() + "','" + card.getElementTyp().name() + "','" + card.getCardType().name() + "')", "Card added");
}
/**
@ -630,14 +639,14 @@ public class DBConnection {
* @param pack Pack welches hinzugefügt werden soll
* @return True bei erfolg, false bei fehler
*/
public boolean addPackage(Package pack) {
public boolean addPackage(at.reisinger.obj.Package pack) {
for (Card ca : pack.getCards()) {
if (!cardExists(ca.getName())) {
if (!addCard(ca)) {
return false;
}
}
if(!PostgresHelper.executeUpdateMessage("INSERT INTO package (\"ID\", \"name\") values (\'" + pack.getName() + "\',\'" + ca.getName() + "\');", "Card zu Package hinzugefügt")){
if(!PostgresHelper.executeUpdateMessage("INSERT INTO package (\"ID\", \"name\") values ('" + pack.getName() + "','" + ca.getName() + "');", "Card zu Package hinzugefügt")){
return false;
}
}
@ -654,7 +663,7 @@ public class DBConnection {
* @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war
*/
public boolean addUser(String username, String password, String nachname, String email, String bio, String image) {
return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password, bio, image) values (\'" + username + "\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\',\'" + bio + "\',\'" + image + "\')", "User added");
return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password, bio, image) values ('" + username + "','" + nachname + "','" + email + "','" + password + "','" + bio + "','" + image + "')", "User added");
}
/**
@ -666,12 +675,7 @@ public class DBConnection {
* @return True bei erfolg, sonst false
*/
public boolean updateUser(String username, String bio, String image, String name){
System.out.println("UPDATE public.users SET nachname = \'"+ name+"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = \'"+ name+"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
}
/**
private boolean updateUser(String username, String name, String bio, String image){
return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = \'"+ name +"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = '" + name+ "', bio = '" +bio+ "', image = '" +image+ "' WHERE username LIKE '" +username+ "' ESCAPE '#'");
}
/**
@ -680,17 +684,15 @@ public class DBConnection {
*
* @param uname Username der zu suchen ist
* @return User als User Objekt, null bei fehler
* @throws SQLException Fehler bei der Suche in der DB
*/
public User getUser(String uname) throws SQLException {
public User getUser(String uname){
this.c = PostgresHelper.con();
String username = "", password = "", email = "", nachname = "", bio="", image="";
String username = "", password = "", email = "", bio="", image="";
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users where username = \'" + uname + "\';");
ResultSet rs = stmt.executeQuery("SELECT * FROM users where username = '" + uname + "';");
while (rs.next()) {
username = rs.getString("username");
nachname = rs.getString("nachname");
email = rs.getString("email");
password = rs.getString("password");
bio = rs.getString("bio");
@ -703,7 +705,6 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
System.out.println("User pulled successfully");
return new User(new Credentials(username, password), username, username, email, new Coins(20), bio, image);
}
@ -713,20 +714,15 @@ public class DBConnection {
* @return Null bei error
*/
public Card getCardFromID(String id){
System.out.println(id);
Connection b = PostgresHelper.con();
Card toreturn = null;
try {
stmt = b.createStatement();
ResultSet rs = stmt.executeQuery("select * from card where NAME = \'" + id + "\';");
ResultSet rs = stmt.executeQuery("select * from card where NAME = '" + id + "';");
while (rs.next()) {
int damage =rs.getInt("damage");
String elementtyp =rs.getString("elementtyp");
String cardtype=rs.getString("cardtype");
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();
@ -736,13 +732,7 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
if (toreturn != null){
System.out.println("Card pulled successfully");
return toreturn;
}else {
System.out.println("Card NOT pulled");
return null;
}
}
/**
@ -751,20 +741,16 @@ public class DBConnection {
* @return Falls null, dann war ein error
*/
public Cards getCardsFromIDList(List<String> cardnamenarray){
Cards allCards = new Cards(new ArrayList<Card>());
Cards allCards = new Cards(new ArrayList<>());
for (String st : cardnamenarray) {
Connection b = PostgresHelper.con();
try {
stmt = b.createStatement();
ResultSet rs = stmt.executeQuery("select * from card where NAME = \'" + st + "\';");
ResultSet rs = stmt.executeQuery("select * from card where NAME = '" + st + "';");
while (rs.next()) {
int damage =rs.getInt("damage");
String elementtyp =rs.getString("elementtyp");
String cardtype=rs.getString("cardtype");
System.out.println("damage = " + damage);
System.out.println("elementtyp = " + elementtyp);
System.out.println("cardtype = " + cardtype);
System.out.println();
allCards.addCard(new Card(st, elementtyp+cardtype, damage));
}
rs.close();
@ -774,7 +760,6 @@ public class DBConnection {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
return null;
}
System.out.println("Card pulled successfully");
}
return allCards;
}
@ -786,18 +771,14 @@ public class DBConnection {
*/
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>();
String cardname;
ArrayList<String> cardnamenarray = new ArrayList<>();
try {
stmt = this.c.createStatement();
ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';");
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();
@ -806,26 +787,6 @@ public class DBConnection {
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
*
* @return Alle Trading Deals
public ArrayList<TradingDeal> getAllTradingDeals() {
return this.tradingDeals;
}
/**
* Fügt einen neuen Tradingdeal zum at.reisinger.Store hinzu
*
* @param tradingDeal Der neue Deal
public void addTradingDeal(TradingDeal tradingDeal) {
this.tradingDeals.add(tradingDeal);
}
*/
}

20
src/main/java/at/reisinger/server/Main.java
View File

@ -1,6 +1,5 @@
package at.reisinger.server;
import at.reisinger.DBConnection;
import at.reisinger.server.objects.Request;
import at.reisinger.server.objects.Response;
@ -15,18 +14,15 @@ import java.net.Socket;
public class Main {
static final int port = 80;
private Socket socket;
private int id;
/**
* Initial Start
* @param args Nicht Verwendet
*/
public static void main(String[] args) {
System.out.println("DB init");
new DBConnection().init();
System.out.println("\n\nStarte Server auf Port " + port + "\n\n");
new Main(port);
}
/**
@ -34,12 +30,9 @@ public class Main {
* @param port Port auf dem der Server läuft
*/
public Main(int port){
ServerSocket serverSocket = null;
ServerSocket serverSocket;
try {
serverSocket = new ServerSocket(port);
//this.msgHandler = new MsgHandler();
//this.id = 0;
while (true){
this.socket = serverSocket.accept();
requestResponding();
@ -54,14 +47,11 @@ public class Main {
*/
public void requestResponding(){
try{
System.out.println("Socket von Client #" + this.id + " wurde gestartet!");
Request rq = new Request(this.socket, this.id);
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();
System.out.println("Socket wurde gestartet!");
Request rq = new Request(this.socket);
new Response(rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload());
this.socket.close();
System.out.println("Socket von Client #" + this.id + " wurde geschlossen!");
System.out.println("Socket wurde geschlossen!");
}catch (IOException e){
e.printStackTrace();
}

4
src/main/java/at/reisinger/server/helper/EnumHelper.java
View File

@ -1,7 +1,7 @@
package at.reisinger.server.helper;
import at.reisinger.CardType;
import at.reisinger.ElementTyp;
import at.reisinger.enums.CardType;
import at.reisinger.enums.ElementTyp;
/**
* Hilft beim manipulieren von enums

55
src/main/java/at/reisinger/server/helper/JsonHelper.java
View File

@ -1,14 +1,10 @@
package at.reisinger.server.helper;
import at.reisinger.Card;
import at.reisinger.Cards;
import at.reisinger.Package;
import at.reisinger.User;
import at.reisinger.obj.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@ -18,24 +14,12 @@ import java.util.Map;
public class JsonHelper {
/**
* Wandelt ein Package in form einer ArrayList<Card> om ein Json um
* @param listCards Cards die in dem Json stehen sollen
* @param name Name des Packages
* @return Json String des Packages
*/
public static String packageListToJson(ArrayList<Card> listCards, String name){
Package packageCards = new Package(new Cards(listCards),name, 5);
return objToJson(packageCards);
}
/**
* Wandelt ein Package Objekt in ein Json um
* Wandelt ein Objekt in ein Json um
* @param obj Objekt das in ein Json umgewandelt werden soll
* @return Json String des Packages
*/
public static String objToJson(Object obj){
ObjectMapper objectMapper = new ObjectMapper();
objectMapper = new ObjectMapper();
String packageJson = "";
if(obj != null) {
try {
@ -49,29 +33,6 @@ 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
@ -80,7 +41,8 @@ public class JsonHelper {
public static List<String> jsonPayloadToList(String payload){
ObjectMapper objectMapper = new ObjectMapper();
try {
return objectMapper.readValue(payload, new TypeReference<List<String>>(){});
return objectMapper.readValue(payload, new TypeReference<>() {
});
} catch (JsonProcessingException e) {
e.printStackTrace();
return null;
@ -95,14 +57,19 @@ public class JsonHelper {
public static Map<String, Object> jsonPayloadToMap(String payload){
ObjectMapper objectMapper = new ObjectMapper();
try {
return objectMapper.readValue(payload, new TypeReference<Map<String,Object>>(){});
return objectMapper.readValue(payload, new TypeReference<>() {
});
} catch (JsonProcessingException e) {
e.printStackTrace();
return null;
}
}
@Deprecated
/**
* Wandelt ein Objekt in ein Json um
* @param user Objekt das in ein Json umgewandelt werden soll
* @return Json String des Packages
*/
public static String userToJson(User user){
return objToJson(user);
}

1
src/main/java/at/reisinger/server/helper/PostgresHelper.java
View File

@ -23,7 +23,6 @@ public class PostgresHelper {
} catch (Exception e) {
e.printStackTrace();
System.err.println(e.getClass().getName() + ": " + e.getMessage());
System.exit(0);
}
return c;
}

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

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

39
src/main/java/at/reisinger/server/objects/Request.java
View File

@ -6,6 +6,7 @@ import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
@ -14,29 +15,23 @@ import java.util.List;
*/
public class Request {
private final Socket socket;
private final int id;
private PrintStream out;
private String cmd;
private String url;
private final StringBuilder rqBuilder;
private String payload;
private String authString;
private final PrintStream out;
private final String cmd;
private final String url;
private final String payload;
private final String authString;
/**
* Get Request
* Besorgt alle nötigen infos aus dem request
* @param socket Socket von dem der Request kommt
* @param id Thread ID
*/
public Request(Socket socket, int id) throws IOException {
this.socket = socket;
this.rqBuilder = new StringBuilder();
this.id = id;
this.out = new PrintStream(this.socket.getOutputStream());
public Request(Socket socket) throws IOException {
StringBuilder rqBuilder = new StringBuilder();
this.out = new PrintStream(socket.getOutputStream());
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line = bufferedReader.readLine();
while (!line.isBlank()) {
rqBuilder.append(line + "\r\n");
rqBuilder.append(line).append("\r\n");
line = bufferedReader.readLine();
System.out.println(line);
}
@ -59,11 +54,7 @@ public class Request {
this.url = path;
this.cmd = method;
List<String> headers = new ArrayList<>();
for (int h = 2; h < requestsLines.length; h++) {
String header = requestsLines[h];
headers.add(header);
}
List<String> headers = new ArrayList<>(Arrays.asList(requestsLines).subList(2, requestsLines.length));
@ -73,11 +64,11 @@ public class Request {
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);
if(authIndexEnd == -1){
authIndexEnd = authString.indexOf(']');
}
authString = authString.substring(0, authIndexEnd);
System.out.println("AUTH STRING: " + authString);
this.authString = authString;
}else{

357
src/main/java/at/reisinger/server/objects/Response.java
View File

@ -1,79 +1,73 @@
package at.reisinger.server.objects;
import at.reisinger.*;
import at.reisinger.Package;
import at.reisinger.obj.*;
import at.reisinger.obj.Package;
import at.reisinger.server.DBConnection;
import at.reisinger.server.helper.JsonHelper;
import at.reisinger.server.helper.PostgresHelper;
import at.reisinger.server.helper.ResponseHelper;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.postgresql.shaded.com.ongres.scram.common.bouncycastle.pbkdf2.Pack;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.*;
/**
* Erstellt und sendet eine Response anhand des Requests
* @author Georg Reisinger
*/
public class Response {
//private final Socket socket;
private final int id;
private PrintStream out;
private String cmd;
private String url;
private String payload;
private String authString;
private final PrintStream out;
private final String url;
private final String payload;
private final String authString;
/**
* Nimmt die Daten des requests und generiert eine Response
* @param id Thread Id
* @param url Request Url
* @param cmd Request CMD
* @param out out Print Stream
* @param authString Der MsgHandler
* @param payload Payload des Requests
*/
public Response(int id, String url, String cmd, PrintStream out, String authString, String payload){
this.id = id;
public Response(String url, String cmd, PrintStream out, String authString, String payload){
this.authString = authString;
this.url = url;
this.cmd = cmd;
this.out = out;
this.payload = payload;
if (this.url != null) {
if (this.cmd.equals("GET")) {
if(login()) {
switch (cmd) {
case "GET":
if (login()) {
getMethodes();
}else{
sendError("401");
} else {
sendResponse("Login Error", "401");
}
}else if (this.cmd.equals("POST")){
break;
case "POST":
try {
postMethodes();
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}else if (this.cmd.equals("PUT")){
if(login()) {
break;
case "PUT":
if (login()) {
putMethodes();
}else{
sendError("401");
} else {
sendResponse("Login Error", "401");
}
}else if (this.cmd.equals("DELETE")){
if(login()) {
break;
case "DELETE":
if (login()) {
deleteMethodes();
}else{
sendError("401");
} else {
sendResponse("Login Error", "401");
}
}else{
sendError("405");
break;
default:
sendResponse("", "405");
break;
}
}
}
@ -85,21 +79,15 @@ public class Response {
private void getMethodes(){
if (this.url.startsWith("/users")) {
String username = this.url.substring(this.url.lastIndexOf('/') + 1);
System.out.println("Username in /users/{username}: " + username);
User user = null;
try {
User user;
user = new DBConnection().getUser(username);
} catch (SQLException throwables) {
throwables.printStackTrace();
sendError("401");
}
if (user != null){
String userJson = JsonHelper.userToJson(user);
if(userJson != null && !userJson.isEmpty()){
sendResponse(userJson, "200");
}
}else{
sendError("500");
sendResponse("", "500");
}
} else if (this.url.startsWith("/cards")) {
String username = basicAuthGetUsername(this.authString);
@ -108,15 +96,14 @@ public class Response {
if (jsonCards != null && !jsonCards.isEmpty()){
sendResponse(jsonCards, "200");
}else{
sendError("500");
sendResponse("", "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;
Cards deck;
Object tmp;
if(format.startsWith("format=plain")){
tmp = allCards;
}else{
@ -127,22 +114,62 @@ public class Response {
if (jsonCards != null && !jsonCards.isEmpty()) {
sendResponse(jsonCards, "200");
} else {
sendError("500");
sendResponse("", "500");
}
}else if(this.url.startsWith("/tradings")) {
ArrayList<TradingDeal> allDeals = new DBConnection().getAllTradingDeals();
if(allDeals != null && !allDeals.isEmpty()){
String json = JsonHelper.objToJson(allDeals);
if(json != null && json != ""){
if(json != null && !json.equals("")){
sendResponse(json, "200");
}else{
sendError("500");
sendResponse("", "500");
}
}else{
sendError("500");
sendResponse("", "500");
}
}else if(this.url.startsWith("/score")) {
String username = basicAuthGetUsername(this.authString);
if (username != null && !username.isEmpty()){
int lastBallteId = new DBConnection().getLastBattleIdUser(username);
if (lastBallteId > -1){
Map<String, String> map = new DBConnection().getBattleLog(lastBallteId + "");
if(map != null && !map.isEmpty()){
sendResponse("BATTLE #" + map.get("id") + "\nSCORE\n" + map.get("playerone") + "(#Player1) |vs| " + map.get("playertwo") + "(#Player2) \n" + map.get("playeronescore") + "(#Player1) |vs| " + map.get("playertwoscore") + "(#Player2) \nGame LOG:\n" + ResponseHelper.logLineBreak(map.get("log")), "200");
}else {
sendResponse("Konnte Battle log nicht holen", "500");
}
}else {
sendResponse("Last Battle ID error", "500");
}
}else{
sendResponse("Login Error", "401");
}
}else if(this.url.startsWith("/stats")) {
String username = basicAuthGetUsername(this.authString);
if (username != null && !username.isEmpty()) {
ArrayList<String> battleIds = new DBConnection().getAllBattleIdUser(username);
if (battleIds != null && !battleIds.isEmpty()){
StringBuilder resString = new StringBuilder();
for(String i : battleIds){
Map<String, String> map = new DBConnection().getBattleLog(i + "");
if(map != null && !map.isEmpty()){
resString = new StringBuilder("BATTLE #" + map.get("id") + "\nSCORE\n" + map.get("playerone") + "(#Player1) |vs| " + map.get("playertwo") + "(#Player2) \n" + map.get("playeronescore") + "(#Player1) |vs| " + map.get("playertwoscore") + "(#Player2) \nGame LOG:\n");
resString.append(ResponseHelper.logLineBreak(map.get("log")));
}else {
sendResponse("Konnte Battle log nicht holen", "500");
}
}
sendResponse(resString.toString(), "200");
}else {
sendResponse("Konnte Battle ids ned holen", "500");
}
}else{
sendError("204");
sendResponse("Login Error", "401");
}
}else{
sendResponse("", "204");
}
}
@ -155,10 +182,7 @@ public class Response {
*/
private boolean basicAuth(String username, String password, String compareTo){
String authStringEnc = basicAuthBase64(username, password);
if (compareTo.equals(authStringEnc)){
return true;
}
return false;
return compareTo.equals(authStringEnc);
}
/**
@ -170,8 +194,7 @@ public class Response {
private String basicAuthBase64(String username, String password){
String authString = username + ":" + password;
byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes());
String authStringEnc = new String(authEncBytes);
return authStringEnc;
return new String(authEncBytes);
}
/**
@ -188,7 +211,7 @@ public class Response {
}else{
values = null;
}
return values[0];
return Objects.requireNonNull(values)[0];
}
/**
@ -201,84 +224,77 @@ public class Response {
private void postMethodes() throws JsonProcessingException {
if (this.url.startsWith("/users")) {
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String username = (String) map.get("Username");
String username = (String) Objects.requireNonNull(map).get("Username");
String password = (String) map.get("Password");
User newUser = new User(new Credentials(username, password), username, username, "not implemented", new Coins(20), "BIO", "IMAGE");
System.out.println("CON DB");
DBConnection con = new DBConnection();
if(!con.addUser(newUser.getCredentials().getUsername(), newUser.getCredentials().getPasswort(), newUser.getCredentials().getUsername(), newUser.getEmail(), newUser.getBio(), newUser.getImage())){
sendError("409");
sendResponse("", "409");
}
String userJson = JsonHelper.userToJson(newUser);;
String userJson = JsonHelper.userToJson(newUser);
if(userJson != null) {
sendResponse(userJson, "201");
}else{
sendError("500");
sendResponse("", "500");
}
}else if (this.url.startsWith("/sessions")) {
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String username = (String) map.get("Username");
String username = (String) Objects.requireNonNull(map).get("Username");
String password = (String) map.get("Password");
User user = null;
User user;
DBConnection con = new DBConnection();
try {
user = con.getUser(username);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
String authString = basicAuthBase64(user.getCredentials().getUsername(), user.getCredentials().getPasswort());
if(basicAuth(username, password, authString)){
sendResponse(authString, "200");
}else{
sendError("401");
sendResponse("Login Error", "401");
}
}else if (this.url.startsWith("/packages")) {
if (basicAuth("admin", "istrator", this.authString)) {
ObjectMapper objectMapper = new ObjectMapper();
ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>() {
ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<>() {
});
Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5);
if (!new DBConnection().addPackage(packageCards)) {
sendError("500");
sendResponse("", "500");
} else {
String packageJson = JsonHelper.objToJson(packageCards);
if (packageJson != null) {
sendResponse(packageJson, "201");
} else {
sendError("500");
sendResponse("", "500");
}
}
} else {
sendError("401");
sendResponse("Login Error", "401");
}
}else if (this.url.startsWith("/transactions/packages")) {
if (login()) {
DBConnection db = new DBConnection();
Package newPackage = db.userAcquirePackage(basicAuthGetUsername(this.authString));
if (newPackage == null) {
sendError("500");
sendResponse("", "500");
} else {
String packageJson = JsonHelper.objToJson(newPackage);
if (packageJson == null) {
sendError("500");
sendResponse("", "500");
} else {
sendResponse(packageJson, "200");
}
}
}else{
sendError("401");
sendResponse("Login Error", "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")) {
if (!dotradeid.isEmpty() && !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()) {
@ -300,54 +316,51 @@ public class Response {
if (new DBConnection().addUserCard(tradingDeal.getUsername(), card.getName())) {
sendResponse(json, "200");
} else {
sendError("500");
sendResponse("ERROR --> Add Card to: " + tradingDeal.getUsername(), "500");
}
} else {
sendError("500");
sendResponse("ERROR --> Del Card from: " + username, "500");
}
} else {
sendError("500");
sendResponse("Error --> Del Trading Deal", "500");
}
} else {
sendError("500");
sendResponse("ERROR --> Del Card from: " + tradingDeal.getUsername(), "500");
}
} else {
sendError("500");
sendResponse("ERROR --> Add Card to: " + username, "500");
}
} else {
sendError("500");
sendResponse("ERROR --> JSON Empty", "500");
}
} else {
sendError("500");
sendResponse("ERROR --> Trading Deal not ok", "500");
}
} else {
sendError("500");
sendResponse("ERROR --> Trading Deal not exist", "500");
}
} else {
sendError("500");
sendResponse("ERROR --> Card not exist", "500");
}
} else {
sendError("500");
sendResponse("ERROR --> Trading Deal not exist", "500");
}
} else {
sendError("401");
sendResponse("ERROR --> Username empty", "401");
}
} else {
//CREATE TRADING DEAL
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String id = (String) map.get("Id");
String id = (String) Objects.requireNonNull(map).get("Id");
String cardtotrade = (String) map.get("CardToTrade");
String type = (String) map.get("Type");
double mindamage = Double.parseDouble(map.get("MinimumDamage") + "");
String username = basicAuthGetUsername(this.authString);
if (username != null) {
Card cardtoTradeC = new DBConnection().getCardFromID(cardtotrade);
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)) {
@ -355,28 +368,22 @@ public class Response {
}
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");
sendResponse(Objects.requireNonNull(JsonHelper.objToJson(tradingDeal)), "201");
} else {
sendError("500");
sendResponse("", "500");
}
} else {
sendError("500");
sendResponse("", "500");
}
} else {
sendError("500");
sendResponse("", "500");
}
sendResponse(tradingJson, "201");
sendResponse(Objects.requireNonNull(tradingJson), "201");
} else {
sendError("500");
sendResponse("", "500");
}
} else {
sendError("500");
}
} else {
sendError("500");
}
} else {
sendError("500");
sendResponse("", "500");
}
}
}
@ -394,95 +401,93 @@ public class Response {
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");
sendResponse("", "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())) {
if(new DBConnection().delBattleEinladung(openBattle.getId() + "")) {
if (openBattle.doFight()){
System.out.println(JsonHelper.objToJson(openBattle.getLog().size()));
if (new DBConnection().addBattleLog(openBattle.getId() + "", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1() + "", openBattle.getScorePlayer2() + "", openBattle.getLog().toString())) {
if (new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) {
//DEL OLD DECK CARDS
ArrayList<String> oldDeck1 = new ArrayList<String>();
for (Card ca: openBattle.getDeckPlayer1Init().getCards()){
ArrayList<String> oldDeck1 = new ArrayList<>();
for (Card ca : openBattle.getDeckPlayer1Init().getCards()) {
oldDeck1.add(ca.getName());
}
ArrayList<String> oldDeck2 = new ArrayList<String>();
for (Card ca: openBattle.getDeckPlayer2Init().getCards()){
ArrayList<String> oldDeck2 = new ArrayList<>();
for (Card ca : openBattle.getDeckPlayer2Init().getCards()) {
oldDeck2.add(ca.getName());
}
//DEL NEW CARDS IF EXIST
Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername());
for(Card ca:openBattle.getDeckPlayer1().getCards()){
for (Card ca : openBattle.getDeckPlayer1().getCards()) {
oldDeck1.add(ca.getName());
}
if(player1cards.getCards() != null && !player1cards.getCards().isEmpty()) {
if (player1cards.getCards() != null && !player1cards.getCards().isEmpty()) {
for (String ca : oldDeck1) {
if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca)){
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()){
for (Card ca : openBattle.getDeckPlayer2().getCards()) {
oldDeck2.add(ca.getName());
}
if(player2cards.getCards() != null && !player2cards.getCards().isEmpty()) {
if (player2cards.getCards() != null && !player2cards.getCards().isEmpty()) {
for (String ca : oldDeck2) {
if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca)){
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())){
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())){
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{
} else {
sendResponse("Battle Log konnte ned geschrieben werden", "500"); //ERROR
}
}else {
sendResponse("Battle konnte ned durchgeführt werden", "500");
}
}else{
sendResponse("Battle einladung konnte ned akzeptiert werden", "500"); //ERROR
}
}else{
sendResponse("GET User error", "500"); //ERROR
}
} 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");
sendResponse("Nur "+ Objects.requireNonNull(deck).getCards().size()+" von 4 Karten im Deck. \nMach zuerst POST /deck [ID, ID, ID, ID] um dein Deck korrekt zu befüllen","424");
}
}else {
sendResponse("Deck ist nicht gesetzt","424");
}
}else {
sendError("500");
sendResponse("", "500");
}
}else {
sendError("401");
sendResponse("Login Error", "401");
}
} else{
sendError("405");
sendResponse("", "405");
}
}
@ -494,18 +499,9 @@ public class Response {
private boolean login(){
if(this.authString != null && !this.authString.isEmpty()){
String username = basicAuthGetUsername(this.authString);
User user = null;
try {
User user;
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;
}
return basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString);
}else{
return false;
@ -515,53 +511,44 @@ public class Response {
/**
* Alle Put Methoden
* Nur für angemeldete user erreichbar
* @throws JsonProcessingException Fehler beim de-/serialisieren
*/
private void putMethodes(){
if (this.url.startsWith("/users")) {
String username = this.url.substring(this.url.lastIndexOf('/') + 1);
System.out.println("Username in /users/{username}: " + username);
User user = null;
try {
User user;
user = new DBConnection().getUser(username);
} catch (SQLException throwables) {
throwables.printStackTrace();
sendError("401");
}
if(user != null) {
Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
String bio = (String) map.get("Bio");
String bio = (String) Objects.requireNonNull(map).get("Bio");
String image = (String) map.get("Image");
String name = (String) map.get("Name");
System.out.println("Request /users:");
System.out.println("Bio: " + bio + "\nImage: " + image + "\nName: " + name);
user.setBio(bio);
user.setImage(image);
user.setNachname(name);
if (new DBConnection().updateUser(username, user.getBio(), user.getImage(), user.getNachname())) {
sendResponse(JsonHelper.userToJson(user), "200");
} else {
sendError("500");
sendResponse("", "500");
}
}else{
sendError("500");
sendResponse("", "500");
}
}else if(this.url.startsWith("/deck")) {
List<String> deckIds = JsonHelper.jsonPayloadToList(this.payload);
if (deckIds != null){
if (deckIds != null && deckIds.size() == 4){
if (new DBConnection().setDeck(basicAuthGetUsername(this.authString), deckIds)){
Cards deck = new DBConnection().getCardsFromIDList(deckIds);
String deckJson = JsonHelper.objToJson(deck);
if (deck != null && deckJson != null){
sendResponse(deckJson, "200");
}else {
sendError("500");
sendResponse("", "500");
}
}else {
sendError("500");
sendResponse("", "500");
}
}else{
sendError("500");
sendResponse(Objects.requireNonNull(deckIds).size() + " von 4 Karten sind im Deck.","500");
}
}
}
@ -571,12 +558,10 @@ public class Response {
/**
* Alle Delete Methoden, siehe API beschreibung für genauere details
* Nur für angemeldete user erreichbar
* @throws JsonProcessingException Fehler beim de-/serialisieren
*/
private void deleteMethodes(){
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()) {
@ -590,10 +575,10 @@ public class Response {
if (new DBConnection().updateCardLock(tr.getCardToTrade().getName(), false))
sendResponse("", "204");
} else {
sendError("500");
sendResponse("", "500");
}
}else{
sendError("500");
sendResponse("", "500");
}
}
@ -601,32 +586,6 @@ public class Response {
}
/**
* Sendet einen Error Response
* @param errorCode Der Error Code
*/
private void sendError(String errorCode) {
out.print("HTTP/1.0 "+errorCode+"\r\n");
out.print("Server: Apache/0.8.4\r\n");
out.print("Content-Type: text/plain\r\n");
out.print("Content-Length: 1\r\n");
out.print("\r\n");
//out.print(responseText);
}
/**
* Sendet eine Startseite, mit allen befehlen und wie man diese verwendet
private void startseite() {
sendResponse("lists all messages: GET /messages<br>" +
"add message: POST /messages (Payload: the message; Response an id like1)<br>" +
"show first message: GET /messages/1<br>" +
"show third message: GET /messages/3<br>" +
"update first message: PUT /messages/1 (Payload: the message)<br>" +
"remove first message: DELETE /messages/1<br>", "200");
}
*/
/**
* Sendet eine Response
* @param responseText Text der zu senden ist

30
src/test/java/CardTest.java
View File

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

28
src/test/java/CardsTest.java
View File

@ -1,27 +1,27 @@
import at.reisinger.Card;
import at.reisinger.CardType;
import at.reisinger.Cards;
import at.reisinger.ElementTyp;
import at.reisinger.obj.Card;
import at.reisinger.enums.CardType;
import at.reisinger.obj.Cards;
import at.reisinger.enums.ElementTyp;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.*;
public class CardsTest {
private Cards cards, cards2, cards3;
private Card newCard, card, newerCard;
private ArrayList<Card> cardsArrayList, cardsArrayList2, cardsArrayList3;
private Card newCard;
private Card card;
private ArrayList<Card> cardsArrayList;
@BeforeEach
void setUp() {
card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
newerCard = new Card("NameNewerer", 100, ElementTyp.FIRE, CardType.MONSTER);
cardsArrayList = new ArrayList<Card>();
cardsArrayList2 = new ArrayList<Card>();
cardsArrayList3 = new ArrayList<Card>();
Card newerCard = new Card("NameNewerer", 100, ElementTyp.FIRE, CardType.MONSTER);
cardsArrayList = new ArrayList<>();
ArrayList<Card> cardsArrayList2 = new ArrayList<>();
ArrayList<Card> cardsArrayList3 = new ArrayList<>();
cardsArrayList.add(card);
cardsArrayList2.add(newCard);
cardsArrayList2.add(card);
@ -66,11 +66,11 @@ public class CardsTest {
cards.delCard(newCard);
assertTrue(cards.getCards().equals(cardsArrayList));
assertEquals(cardsArrayList, cards.getCards());
}
@Test
void test_getCards() {
assertTrue(cards.getCards().equals(cardsArrayList));
assertEquals(cardsArrayList, cards.getCards());
}
}

55
src/test/java/CoinsTest.java
View File

@ -1,10 +1,8 @@
import at.reisinger.Coins;
import at.reisinger.NegativAmountException;
import at.reisinger.obj.Coins;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assertions.assertFalse;
public class CoinsTest {
@ -14,55 +12,4 @@ public class CoinsTest {
assertTrue(coin.getCoinAmount() >= 0);
}
@Test
public void test_addCoinException(){
try {
Coins coin = new Coins(10);
coin.addCoin(-10);
fail("Erwartet at.reisinger.NegativAmountException - addCoin");
}catch (NegativAmountException negativAmountException) {
assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"));
}
}
@Test
public void test_removeCoinException(){
try {
Coins coin = new Coins(10);
coin.removeCoin(-10);
fail("Erwartet at.reisinger.NegativAmountException - removeCoin");
}catch (NegativAmountException negativAmountException) {
assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"));
}
}
@Test
public void test_removeCoin(){
Coins coin = new Coins(10);
try {
assertTrue(coin.removeCoin(10));
} catch (NegativAmountException e) {
e.printStackTrace();
}
}
@Test
public void test_changeCoinAmount_true(){
Coins coin = new Coins(10);
try {
assertTrue(coin.changeCoinAmmount(10));
} catch (NegativAmountException e) {
e.printStackTrace();
}
}
@Test
public void test_changeCoinAmount_false(){
Coins coin = new Coins(9);
try {
assertTrue(coin.changeCoinAmmount(7));
} catch (NegativAmountException e) {
e.printStackTrace();
}
}
}

34
src/test/java/PackageTest.java
View File

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

48
src/test/java/StackTest.java
View File

@ -1,48 +0,0 @@
import at.reisinger.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class StackTest {
private Cards newCards, cards, nochNewCards;
private Card newCard, card;
private ArrayList<Card> cardsArrayList, cardsArrayList2, cardsArrayList3;
private Stack stack;
@BeforeEach
void setUp() {
card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
cardsArrayList = new ArrayList<Card>();
cardsArrayList2 = new ArrayList<Card>();
cardsArrayList3 = new ArrayList<Card>();
cardsArrayList.add(card);
cardsArrayList2.add(newCard);
cardsArrayList2.add(card);
cards = new Cards(cardsArrayList);
newCards = new Cards(cardsArrayList2);
nochNewCards = new Cards(cardsArrayList3);
stack = new Stack(cards, nochNewCards);
}
@Test
void test_addDeck() {
stack.addDeck(newCards);
Cards result = stack.getDeck();
assertTrue(result.equals(newCards));
}
@Test
void test_delDeck() {
stack.addDeck(newCards);
stack.delDeck(newCard);
assertTrue(stack.getDeck().equals(cards));
}
@Test
void test_getDeck() {
Cards result = stack.getDeck();
assertTrue(result.equals(nochNewCards));
}
}

147
src/test/java/StoreTest.java
View File

@ -1,147 +0,0 @@
import at.reisinger.*;
import at.reisinger.Package;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class StoreTest {
private TradingDeal tradingDeal;
private Cards newCards, cards, nochNewCards;
private Card newCard, card;
private ArrayList<Card> cardsArrayList, cardsArrayList2, cardsArrayList3;
private Stack stack;
private User user, userNew;
private Store store;
@BeforeEach
void setUp() {
//at.reisinger.Stack
card = new Card("Name", 100, ElementTyp.WATER, CardType.MONSTER);
newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
cardsArrayList = new ArrayList<Card>();
cardsArrayList2 = new ArrayList<Card>();
cardsArrayList3 = new ArrayList<Card>();
cardsArrayList.add(card);
cardsArrayList2.add(newCard);
cards = new Cards(cardsArrayList);
newCards = new Cards(cardsArrayList2);
nochNewCards = new Cards(cardsArrayList3);
stack = new Stack(cards, nochNewCards);
//at.reisinger.Coins
Coins coins = new Coins(10);
//at.reisinger.User
Credentials credentials = new Credentials("username", "passwort");
user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE");
//Trading Deal
Card cardToTrade = card;
ElementTyp requiredElementType = ElementTyp.FIRE;
double requiredMinDamage = 100;
CardType requiredCardType = CardType.MONSTER;
tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME");
}
/*
@Test
void test_addTradingDeal() {
Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL);
Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER);
Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL);
Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER);
ArrayList<Card> deckArrList = new ArrayList<Card>();
ArrayList<Card> stackArrList = new ArrayList<Card>();
deckArrList.add(c1);
deckArrList.add(c2);
stackArrList.add(c3);
stackArrList.add(c4);
stackArrList.add(c5);
Cards deck = new Cards(deckArrList);
Cards stack = new Cards(stackArrList);
User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Coins(1000), "BIO", "IMAGE");
ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
ArrayList<Package> packages = new ArrayList<at.reisinger.Package>();
tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100));
System.out.println(user.getTradingDeals().toString());
user.addTradingDeal(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
System.out.println(user.getTradingDeals().toString());
System.out.println(tradingDeals.toString());
assertTrue(user.getTradingDeals().get(0).dealOk(tradingDeals.get(0)));
}
@Test
void test_doTrade() {
Card cardtest = new Card("Name", 100, ElementTyp.FIRE, CardType.MONSTER);
TradingDeal tradingDealtest = new TradingDeal(user, cardtest, ElementTyp.WATER, 100, CardType.MONSTER);
boolean result = user.doTrading(tradingDeal, tradingDealtest);
assertTrue(result);
}
@Test
void test_getTradingDeals() {
ArrayList<TradingDeal> result = user.getTradingDeals();
ArrayList<TradingDeal> expected = new ArrayList<TradingDeal>();
Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL);
Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER);
Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL);
Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER);
ArrayList<Card> deckArrList = new ArrayList<Card>();
ArrayList<Card> stackArrList = new ArrayList<Card>();
deckArrList.add(c1);
deckArrList.add(c2);
stackArrList.add(c3);
stackArrList.add(c4);
stackArrList.add(c5);
Cards deck = new Cards(deckArrList);
Cards stack = new Cards(stackArrList);
User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Coins(1000), "BIO", "IMAGE");
ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
ArrayList<at.reisinger.Package> packages = new ArrayList<at.reisinger.Package>();
tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100));
assertTrue(result.get(0).dealOk(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)));
}
@Test
void test_getPossibleTradingDeals() {
Card testCard = new Card("Test", 10, ElementTyp.FIRE, CardType.MONSTER);
ArrayList<TradingDeal> result = user.getPossibleTradingDeals(testCard);
ArrayList<TradingDeal> expected = new ArrayList<TradingDeal>();
Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL);
Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER);
Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL);
Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER);
ArrayList<Card> deckArrList = new ArrayList<Card>();
ArrayList<Card> stackArrList = new ArrayList<Card>();
deckArrList.add(c1);
deckArrList.add(c2);
stackArrList.add(c3);
stackArrList.add(c4);
stackArrList.add(c5);
Cards deck = new Cards(deckArrList);
Cards stack = new Cards(stackArrList);
TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "DerName", "Nachname", "Email", new Coins(1000), "BIO", "IMAGE"), c1, ElementTyp.FIRE, 10, CardType.SPELL);
expected.add(vonDB);
System.out.println(result.get(0).getCardToTrade().getName());
System.out.println(expected.get(0).getCardToTrade().getName());
assertTrue(result.get(0).getCardToTrade().equals(expected.get(0).getCardToTrade()));
}
*/
}

62
src/test/java/TradingDealTest.java
View File

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

57
src/test/java/UserTest.java
View File

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