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