Програмка на Java для Ультимейт покера

package com.ultimate.objects;

public class Card {
    // Масть карты (пики, черви, бубны, трефы)
    private String suit;
    // Ранг карты (2-10, J, Q, K, A)
    private int rank;

    public Card(String suit, int rank) {
        this.suit = suit;
        this.rank = rank;
    }

    public String getSuit() {
        return suit;
    }

    public void setSuit(String suit) {
        this.suit = suit;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }

    @Override
    public String toString() {
        return rankToString(rank) + " of " + suit;
    }

    private String rankToString(int rank) {
        if (rank == 11) return "Jack";
        if (rank == 12) return "Queen";
        if (rank == 13) return "King";
        if (rank == 14) return "Ace";
        return String.valueOf(rank);
    }
}
 

package com.ultimate.objects;

import java.util.ArrayList;
import java.util.List;

public class Player {
    private String name;
    List<Card> hand = new ArrayList<>();

    public Player(String name) {
        this.name = name;
    }

    public void addCard(Card card) {
        hand.add(card);
    }

    @Override
    public String toString() {
        return name + "'s hand: " + hand;
    }
}
 

package com.ultimate.objects;

import java.util.*;
import java.util.stream.Collectors;

public class BestHand {
    private List<Card> playerCards;
    private List<Card> communityCards;
    private List<Card> getAllCards;

    private List<Card> allCards;

    public BestHand(List<Card> playerCards, List<Card> communityCards) {
        allCards = new ArrayList<>(communityCards);
        allCards.addAll(playerCards); // Объединяем карты игрока и общие карты
    }

    // Проверка на флеш
    private static boolean isFlush(List<Card> cards) {
        return cards.stream()
                .collect(Collectors.groupingBy(card -> card.getSuit()))
                .values().stream()
                .anyMatch(suitGroup -> suitGroup.size() >= 5);
    }

    // Проверка на стрит
    private static boolean isStraight(List<Card> cards) {
        List<Integer> ranks = cards.stream()
                .map(card -> card.getRank())
                .distinct()
                .sorted()
                .collect(Collectors.toList());

        for (int i = 0; i <= ranks.size() - 5; i++) {
            if (ranks.get(i + 4) - ranks.get(i) == 4) return true;
        }

        // Проверка на стрит с тузом (A, 2, 3, 4, 5)
        return ranks.containsAll(Arrays.asList(2, 3, 4, 5, 14));
    }

    // Проверка на стрит-флеш
    private static boolean isStraightFlush(List<Card> cards) {
        Map<String, List<Card>> suits = cards.stream()
                .collect(Collectors.groupingBy(card -> card.getSuit()));

        for (List<Card> suitCards : suits.values()) {
            if (isStraight(suitCards)) return true;
        }
        return false;
    }

    // Проверка на каре
    private static boolean isFourOfAKind(List<Card> cards) {
        return hasOfAKind(cards, 4);
    }

    // Проверка на фул-хаус
    private static boolean isFullHouse(List<Card> cards) {
        return isThreeOfAKind(cards) && isPair(cards);
    }

    // Проверка на тройку
    private static boolean isThreeOfAKind(List<Card> cards) {
        return hasOfAKind(cards, 3);
    }

    // Проверка на две пары
    private static boolean isTwoPair(List<Card> cards) {
        return cards.stream()
                .collect(Collectors.groupingBy(card -> card.getRank()))
                .values().stream()
                .filter(rankGroup -> rankGroup.size() == 2)
                .count() >= 2;
    }

    // Проверка на пару
    private static boolean isPair(List<Card> cards) {
        return hasOfAKind(cards, 2);
    }

    // Проверка на конкретное количество одинаковых карт
    private static boolean hasOfAKind(List<Card> cards, int count) {
        return cards.stream()
                .collect(Collectors.groupingBy(card -> card.getRank()))
                .values().stream()
                .anyMatch(rankGroup -> rankGroup.size() == count);
    }

    public String getCombination() {
        // Проверяем комбинации от самой сильной к самой слабой
        if (isStraightFlush(allCards)) return "Straight Flush";
        if (isFourOfAKind(allCards)) return "Four of a Kind";
        if (isFullHouse(allCards)) return "Full House";
        if (isFlush(allCards)) return "Flush";
        if (isStraight(allCards)) return "Straight";
        if (isThreeOfAKind(allCards)) return "Three of a Kind";
        if (isTwoPair(allCards)) return "Two Pair";
        if (isPair(allCards)) return "Pair";
        return "High Card";

    }
}
 

package com.ultimate;

import com.ultimate.objects.Card;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Deck {
    private List<Card> cards;

    /**
     * Конструктор создаёт новую колоду карт и тасует её
     */
    public Deck() {
        cards = new ArrayList<>();
        initializeDeck();
        shuffle();
    }

    /**
     * Метод для инициализации колоды (добавления всех карт)
     */
    private void initializeDeck() {
        String[] suits = {"♥", "♦", "♣", "♠"};
        int[] ranks = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};

        for (String suit : suits) {
            for (int rank : ranks) {
                cards.add(new Card(suit, rank));
            }
        }
    }

    /**
     * Метод для тасовки колоды
     */
    public void shuffle() {
        Collections.shuffle(cards);
    }

    /**
     * Метод для раздачи карты из колоды
     */
    public Card dealCard() {
        if (cards.isEmpty()) {
            System.out.println("The deck is empty. Cannot deal any more cards.");
            return null;
        }
        return cards.remove(cards.size() - 1);
    }

    /**
     * Метод для раздачи нескольких карт
     */
    public List<Card> dealMultipleCards(int count) {
        List<Card> dealtCards = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            Card card = dealCard();
            if (card != null) {
                dealtCards.add(card);
            } else {
                break;
            }
        }
        return dealtCards;
    }

    /**
     * Метод для добавления карты в колоду
     */
    public void addCard(Card card) {
        cards.add(card);
    }

    /**
     * Метод для проверки, пуста ли колода
     */
    public boolean isEmpty() {
        return cards.isEmpty();
    }

    /**
     * Метод для удаления конкретной карты из колоды
     */
    public boolean removeCard(Card card) {
        return cards.remove(card);
    }

    /**
     * Метод для проверки, содержит ли колода конкретную карту
     */
    public boolean containsCard(Card card) {
        return cards.contains(card);
    }

    /**
     * Метод для получения количества оставшихся карт в колоде
     */
    public int remainingCards() {
        return cards.size();
    }

    /**
     * Метод для восполнения колоды и её тасовки
     */
    public void resetDeck() {
        cards.clear();
        initializeDeck();
        shuffle();
    }

    /**
     * Метод для отображения всех карт в колоде
     */
    public void displayDeck() {
        for (Card card : cards) {
            System.out.println(card);
        }
    }
    /**
     * Метод для "сжигания" (удаления) карты из колоды
     */
    public Card burnCard() {
        if (cards.isEmpty()) {
            System.out.println("The deck is empty. No card to burn.");
            return null;
        }
        return cards.remove(cards.size() - 1);
    }
}