Poker Spiel Hand Evaluator Arrays Zustand Struktur

Question

Ich machte ein schnelles Pokerspiel. Es erzeugt 5 Zufallszahlen und wandelt diese Zahlen basierend auf ihrem Wert in tatsächliche Kartenwerte und Symbole um. Ich habe jedoch Probleme, wenn es um die Handauswertung geht.

Bis jetzt habe ich nur den Flush richtig gemacht, da es wirklich einfach ist, aber selbst dann ist es nicht perfekt (es druckt, dass der Benutzer einen Flush 5 mal hat ...) und ich würde es sehr schätzen, wenn mir jemand mit dem Paar helfen könnte , zwei Paare, drei von einer Art und gerade. Ich könnte den Rest danach machen, aber ich brauche nur ein Heads-Up, wie man das macht.

Vielen Dank im Voraus für Ihre Hilfe, hier ist der Code:

package tests; 

import java.util.*; 

public class TESTS { 

public static void main(String[] args) { 
    boolean[] pack = new boolean[52]; // Array to not generate the same number twice 
    int[] cards = new int[5]; //The 5 unique random numbers are stored in here. 
    String[] cardsvalues = new String[5]; // This will assign the card's value based on the random number's value 
    char[] cardssymbols = new char[5];//This will assign the card's symbol based on the random number's value 
    char symbols[] = {'♥', '♦', '♣', '♠'}; // possible symbols that the random number can take 
    String values[] = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"}; // possible values that the random number can take 
    Random give = new Random(); 

    for (int i = 0; i < cards.length; i++) { // Gives 5 unique random numbers 
     do { 
      cards[i] = give.nextInt(52); 
     } while (pack[cards[i]]); 
     pack[cards[i]] = true; 
     System.out.println(cards[i]); 
    } 

    for (int i = 0; i < cards.length; i++) { // This converts the number to a card symbol based on the number's value 
     final int numOfSymbol = cards[i]/13; 
     cardssymbols[i] = symbols[numOfSymbol]; 
    } 
    for (int i = 0; i < cards.length; i++) { // This converts the number to an actual card value based on the number's value. 
     final int numOfValues = cards[i] % 13; 
     cardsvalues[i] = values[numOfValues]; 
    } 
    for (int i = 0; i < cardssymbols.length; i++) { // Prints the actual cards once they are converted 
     System.out.print(cardssymbols[i]); 
     System.out.println(cardsvalues[i]); 
    } 
    for (int i = 0; i < cardsvalues.length; i++) { //Here is the problem, i have no idea on how to make the handevaluator ... 
     if (cardsvalues[i] == cardsvalues[i] + 1) { 
      System.out.println("PAIR !!!"); 
     } else if (cardsvalues[i] == cardsvalues[i] + 1 && cardsvalues[i] == cardsvalues[i] + 2) { 
      System.out.println("TRIPS !!!"); 
     } else if (cardssymbols[0] == cardssymbols[1] && cardssymbols[1] == cardssymbols[2] && cardssymbols[2] == cardssymbols[3] && cardssymbols[3] == cardssymbols[4]) { 
      System.out.println("FLUSHHH"); 
     } 
    } 
} 

Answer 1

Hinweise:

• Tests für Straights zu vereinfachen und durch höchste Card Sorting ist es einfacher Rängen zu vertreten durch ihre Indizes und übersetzen sie nur in die Symbole zum Drucken.
• Die Verwendung eines Kartenobjekts ermöglicht klareren Code.
• Das Framework Java Collection enthält nützliche Funktionen zum Mischen, Slicen und Sortieren.

Meine Lösung:

public class Test { 

    static final char[] suits = {'♥', '♦', '♣', '♠'}; 
    static final String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"}; 

    static class Card { 
     final int suit; 
     final int rank; 

     Card(int s, int r) { 
      suit = s; 
      rank = r; 
     } 

     @Override 
     public String toString() { 
      return suits[suit] + ranks[rank]; // or however you want the cards to be printed 
     } 
    } 


    public static void main(String[] args) { 
     List<Card> deck = new ArrayList<>(); 
     for (int s = 0; s < suits.length; s++) { 
      for (int r = 0; r < ranks.length; r++) { 
       deck.add(new Card(s,r)); 
      } 
     } 
     Collections.shuffle(deck); 
     List<Card> hand = deck.subList(0,5); 

     Collections.sort(hand, Comparator.comparing(c -> c.rank)); 
     System.out.println("Your hand is: " + hand); 

     System.out.println(value(hand)); 

    } 

    static String value(List<Card> hand) { 
     boolean straight = true; 
     boolean flush = true; 
     for (int i = 1; i < hand.size(); i++) { 
      straight &= hand.get(i - 1).rank + 1 == hand.get(i).rank; 
      flush &= hand.get(i - 1).suit == hand.get(i).suit; 
     } 

     if (straight && flush) { 
      return "Straight Flush from " + hand.get(4); 
     } 

     List<Run> runs = findRuns(hand); 
     runs.sort(Comparator.comparing(r -> -r.rank)); 
     runs.sort(Comparator.comparing(r -> -r.length)); 

     if (runs.get(0).length == 4) { 
      return "Four of a Kind: " + runs; 
     } 

     if (runs.get(0).length == 3 && runs.get(1).length == 2) { 
      return "Full House: " + runs; 
     } 

     if (straight) { 
      return "Straight from " + hand.get(4); 
     } 

     if (runs.get(0).length == 3) { 
      return "Three of a Kind: " + runs; 
     } 

     if (runs.get(1).length == 2) { 
      return "Two pair: " + runs; 
     } 

     if (runs.get(0).length == 2) { 
      return "Pair: " + runs; 
     } 

     return "High card: " + runs; 
    } 

    /** Represents {@code length} cards of rank {@code rank} */ 
    static class Run { 
     int length; 
     int rank; 

     @Override 
     public String toString() { 
      return ranks[rank]; 
     } 
    } 

    static List<Run> findRuns(List<Card> hand) { 
     List<Run> runs = new ArrayList<>(); 
     Run run = null; 
     for (Card c : hand) { 
      if (run != null && run.rank == c.rank) { 
       run.length++; 
      } else { 
       run = new Run(); 
       runs.add(run); 
       run.rank = c.rank; 
       run.length = 1; 
      } 
     } 
     return runs; 
    } 
} 

Beispiel Ausgabe:

Your hand is: [♣10, ♥J, ♦J, ♠K, ♥K] 
Two pair: [K, J, 10]