Jo moin, ich habe ein Programm geschrieben, welches aus einem 7Hand Pokerdeck die beste Kombination errechnet. Da wollte ich fragen, ob da wer mal rüberschauen kann, ob ich irgendwo unnützes Zeug eingebaut habe oder wie / ob man an den kommentierten Stellen einen Quicksort einbauen könnte.
Danke für Hilfe!
Code:
package Game;
import java.util.ArrayList;
import java.util.Iterator;
public class management {
// Notiz: als nächstes neue Funktionen machen, die die Blätter und andere die
// die Beikarten returnen
// Notiz: getPairs noch richtig sortieren
public static void main(String[] args) {
management m = new management();
m.alphaTest();
}
private ArrayList<card> cards;
private ArrayList<player> players;
// ArrayList<KI> KIs;
private stack stack;
public management() {
cards = new ArrayList<card>();
players = new ArrayList<player>();
stack = new stack();
}
public boolean addCard() {
if (cards.size() <= 5) {
if (stack.dragCard() != null) {
cards.add(stack.dragCard());
return true;
} else
return false;
} else
return false;
}
public boolean addCards(int amount) {
if (amount <= 5 - cards.size()) {
for (int i = 0; i <= amount; i++) {
card card = stack.dragCard();
if (card != null) {
cards.add(card);
} else
return false;
}
return true;
} else
return false;
}
public void addPlayer() {
player p = new player();
p.addCards(stack.dragCard(), stack.dragCard());
players.add(p);
}
public void addPlayer(String name) {
player p = new player(name);
p.addCards(stack.dragCard(), stack.dragCard());
players.add(p);
}
public void alphaTest() {
addPlayer("Kai");
addPlayer("Manfred");
addPlayer("Manfred");
addPlayer("Manfred");
addPlayer("Manfred");
addPlayer("Manfred"); // prüfen ob der gewettet hat
players.get(0).bet(10);
players.get(1).bet(10);
players.get(2).bet(10);
players.get(3).bet(10);
players.get(4).bet(10);
players.get(5).bet(10);
cards.add(new card("Herz", "König")); // von Stapel nehmen damit keine Fehler auftreten
cards.add(new card("Herz", "Bube"));
cards.add(new card("Herz", "Ass"));
cards.add(new card("Herz", "10"));
cards.add(new card("Pik", "Dame"));
win();
}
private ArrayList<card> arrayListOfPairs(ArrayList<ArrayList<card>> cards) {
ArrayList<card> normalList = new ArrayList<card>();
Iterator<ArrayList<card>> it = cards.iterator();
while (it.hasNext()) {
normalList.addAll(it.next());
}
return normalList;
}
private boolean assertConsecutiveRanks(card card1, card card2) {
return card1.getValue() == card2.getValue() - 1 || (card1.getValue() == 14 && card2.getValue() == 2)
|| (card1.getValue() == card2.getValue());
}
private int compareCards(card card1, card card2) {
if (card1.getValue() > card2.getValue())
return 1;
else if (card2.getValue() > card1.getValue())
return 2;
else
return 0;
}
private player comparePlayers(player player1, player player2) {
ArrayList<card> firstDeck = new ArrayList<card>(player1.getWholeDeck());
ArrayList<card> secondDeck = new ArrayList<card>(player2.getWholeDeck());
for (int i = 0; i < firstDeck.size() - 1; i++) {
if (compareCards(firstDeck.get(0), secondDeck.get(0)) == 1) {
return player1;
} else if (compareCards(firstDeck.get(0), secondDeck.get(0)) == 2) {
return player2;
} else {
firstDeck.remove(0);
secondDeck.remove(0);
}
}
return null;
}
private ArrayList<card> flushCards(ArrayList<card> cards) {
ArrayList<card> Herz = new ArrayList<card>();
ArrayList<card> Karo = new ArrayList<card>();
ArrayList<card> Kreuz = new ArrayList<card>();
ArrayList<card> Pik = new ArrayList<card>();
for (card card : cards) {
if (card.getKind() == "Herz") {
Herz.add(card);
} else if (card.getKind() == "Karo") {
Karo.add(card);
} else if (card.getKind() == "Kreuz") {
Kreuz.add(card);
} else if (card.getKind() == "Pik") {
Pik.add(card);
}
}
if (Herz.size() >= 5) {
return Herz;
} else if (Karo.size() >= 5) {
return Karo;
} else if (Kreuz.size() >= 5) {
return Kreuz;
} else if (Pik.size() >= 5) {
return Pik;
} else {
return null;
}
}
private ArrayList<player> getCombination(ArrayList<player> players, String combination) {
ArrayList<player> winList = new ArrayList<player>();
Iterator<player> it = players.iterator();
while (it.hasNext()) {
player player = it.next();
String s = player.getDeck();
if (combination.equals(player.getDeck())) {
winList.add(player);
}
}
return winList;
}
private ArrayList<card> getDeck(player player) {
ArrayList<card> linkedList = new ArrayList<card>();
linkedList.addAll(cards);
linkedList.addAll(player.getCards());
return linkedList;
}
private int getNumberOfPairs(ArrayList<ArrayList<card>> pairs) {
return pairs.size();
}
// general principle of pairs from:
// https://github.com/dwdyer/poker/blob/master/game/src/java/main/org/uncommons/poker/game/cards/SevenCardHandEvaluator.java
private ArrayList<ArrayList<card>> getPairs(ArrayList<card> cards) {
ArrayList<ArrayList<card>> pairs = new ArrayList<ArrayList<card>>();
ArrayList<card> pair = new ArrayList<card>();
int prevValue = cards.get(0).getValue();
pair.add(cards.get(0));
for (int i = 1; i < cards.size(); i++) {
int value = cards.get(i).getValue();
if (value == prevValue) {
pair.add(cards.get(i));
System.out.print("Value: ");
System.out.println(value);
} else if(i+1 == cards.size()) {
pair.add(cards.get(i));
System.out.println("größe pair: "+pair.size()+"");
System.out.print("Value: ");
System.out.println(value);
pairs.add(pair); System.out.println("runned");
pair = new ArrayList<card>();
}
else {
pairs.add(pair);
System.out.println("größe pair: "+pair.size()+"");
pair = new ArrayList<card>();
pair.add(cards.get(i));
prevValue = value;
}
}
ArrayList<ArrayList<card>> newList = new ArrayList<ArrayList<card>>(sortPairs(pairs)); // vielleicht besser umsetzen
System.out.println("Größtes pair");
System.out.println(newList.get(0).size());
System.out.println(newList.get(1).size());
System.out.println(newList.get(2).size());
System.out.println(newList.get(3).size());
System.out.println(newList.get(4).size());
System.out.println(newList.size());
return newList;
}
public void newRound() {
stack.addCards(cards);
for (player player : players) {
stack.addCards(player.getCards());
player.resetCards();
}
stack.mixCards();
addCards(3);
for (player player : players) {
player.addCards(stack.dragCard(), stack.dragCard());
}
}
private String pairToRank(int pairs, int biggestGroup) {
System.out.println();
System.out.println(biggestGroup);
switch (biggestGroup) {
case 1:
System.out.println("Pairs: "+pairs+"");
return "High Card";
case 2:
System.out.println("Pairs: "+pairs+"");
if (pairs == 1)
return "Pair";
else
return "Two Pair";
case 3:
if (pairs == 5)
return "Three of a Kind";
else
return "Full House";
case 4:
return "Four of a Kind";
default:
System.out.println("Error");
return "";
}
}
private void playerDeck(player player) {
boolean straight = false;
boolean flush = false;
ArrayList<card> deck = new ArrayList<card>();
deck.addAll(getDeck(player));
System.out.println(deck.size());
String rank;
deck = sortAfterValue(deck);
ArrayList<ArrayList<card>> pairs = getPairs(deck);
rank = pairToRank(getNumberOfPairs(pairs), returnSizeOfBiggestPair(pairs));
System.out.println(rank);
if (straightCards(deck).size() >= 5) {
deck = straightCards(deck);
toFive(deck);
straight = true;
System.out.println("Straight");
}
if (flushCards(deck) != null && flushCards(deck).size() >= 5) {
flush = true;
toFive(deck);
System.out.println("Flush");
}
if (rank != "Four of a Kind" && rank != "Full House") {
if (straight == true) {
rank = "Straight";
} else if (flush == true) {
rank = "Flush";
}
}
if (straight == true && flush == true) {
if (deck.get(0).getValue() == 14) {
rank = "Royal Flush";
} else {
rank = "Straight Flush";
}
}
toFive(deck);
player.setDeck(rank);
player.setWholeDeck(deck);
System.out.println(deck.get(0).getValue());
System.out.println(player.getDeck());
}
public boolean removePlayer(int index) {
try {
players.remove(index);
} catch (IndexOutOfBoundsException e) {
return false;
}
return true;
}
private int returnSizeOfBiggestPair(ArrayList<ArrayList<card>> pairs) {
return pairs.get(0).size();
}
private ArrayList<card> sortAfterValue(ArrayList<card> cards) {
ArrayList<card> sortedList = new ArrayList<card>();
int maxVal = 14;
// maybe later: quicksort
for (int i = maxVal; i > 1; i--) {
for (int k = 0; k < cards.size(); k++) {
if (cards.get(k).getValue() == i) {
sortedList.add(cards.get(k));
}
}
}
return sortedList;
}
private ArrayList<ArrayList<card>> sortPairs(ArrayList<ArrayList<card>> pairs) {
ArrayList<ArrayList<card>> sortedList = new ArrayList<ArrayList<card>>();
int maxVal = 14;
// maybe later: quicksort
for (int i = 4; i > 0; i--) { // length
for (int j = maxVal; j > 1; j--) { // value
for (int k = 0; k < pairs.size(); k++) { // go through for every pair
if (pairs.get(k).size() == i && pairs.get(k).get(0).getValue() == j) {
sortedList.add(pairs.get(k));
}
}
}
}
return sortedList;
}
private ArrayList<card> straightCards(ArrayList<card> cards) { // zuerst sortieren und 5 karten eingeben, da
// ansonsten ungenauigkeiten auftreten
ArrayList<card> straightCards = new ArrayList<card>();
card highestCard = cards.get(0);
if (highestCard.getValue() == 14 && cards.get(cards.size() - 1).getValue() == 2) {
cards = new ArrayList<card>(cards);
cards.add(highestCard); // höchste karte ans ende bringen
cards.remove(0);
highestCard = cards.get(0);
}
straightCards.add(highestCard);
card prevCard = highestCard;
for (int i = 1; i < cards.size(); i++) {
card card = cards.get(i);
if (assertConsecutiveRanks(card, prevCard)) {
if (card.getValue() != prevCard.getValue())
straightCards.add(card);
if (straightCards.size() == 5) {
return straightCards;
}
} else {
straightCards.clear();
straightCards.add(highestCard);
}
prevCard = card;
}
return straightCards;
}
private ArrayList<card> toFive(ArrayList<card> cards) {
for (int i = cards.size(); i > 5; i--) {
cards.remove(cards.size() - 1);
}
return cards;
}
public void win() {
ArrayList<player> wonList = new ArrayList<player>();
int pot = 0;
for (int i = 0; i < players.size(); i++) {
player player = players.get(i);
if (player.getEntry() != 0 || player.getAction() != null || player.getAction() != "call") {
playerDeck(player);
pot += player.getEntry();
player.looseEntry();
}
}
if (getCombination(players, "Royal Flush").size() != 0) {
wonList.addAll(getCombination(players, "Royal Flush"));
} else if (getCombination(players, "Straight Flush").size() != 0) {
wonList.addAll(getCombination(players, "Straight Flush"));
} else if (getCombination(players, "Four of a Kind").size() != 0) {
wonList.addAll(getCombination(players, "Four of a Kind"));
} else if (getCombination(players, "Full House").size() != 0) {
wonList.addAll(getCombination(players, "Full House"));
} else if (getCombination(players, "Flush").size() != 0) {
wonList.addAll(getCombination(players, "Flush"));
} else if (getCombination(players, "Straight").size() != 0) {
wonList.addAll(getCombination(players, "Straight"));
} else if (getCombination(players, "Three of a Kind").size() != 0) {
wonList.addAll(getCombination(players, "Three of a Kind"));
} else if (getCombination(players, "Two Pair").size() != 0) {
wonList.addAll(getCombination(players, "Two Pair"));
} else if (getCombination(players, "Pair").size() != 0) {
wonList.addAll(getCombination(players, "Pair"));
} else {
wonList.addAll(getCombination(players, "High Card"));
}
System.out.println(wonList.get(0).getDeck());
if (wonList.size() > 1) {
for (int i = 0; i < wonList.size(); i++) { // jeden Spieler mit jedem vergleichen
player player1 = wonList.get(i);
for (int j = 0; j < wonList.size(); j++) {
player player2 = wonList.get(j);
player comp = comparePlayers(player1, player2);
if (comp != null) {
if (comp.equals(player1)) {
wonList.remove(player2);
} else if (comp.equals(player2)) {
wonList.remove(player1);
break;
}
}
}
}
}
if (true) {
pot /= wonList.size();
Iterator<player> it = wonList.iterator();
while (it.hasNext()) {
player player = it.next();
player.addChips(pot);
System.out.println(player.getName());
System.out.println(pot);
}
}
}
}