Ура! Я залил это!

Game.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
+

src/com/company/Card.java

@@ -0,0 +1,39 @@
+package com.company;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Card {
+    // Номинал карты (2 - 14)
+    private int Denomination;
+    // Масть карты
+    Lear.NAME Lear;
+    // Флаг, отвечающий за выдачу этой карты на руки игроку
+    boolean onHands = false;
+
+    /**
+     * Получить номинал карты
+     * @return int
+     */
+    public int getDenomination() {
+        return Denomination;
+    }
+
+    /**
+     * Установить номинал карты. Диапазон допустимых значений 2-14.
+     * @param denomination номинал карты
+     * @return true если удалось установить
+     */
+    public boolean setDenomination(int denomination) {
+        // Проверим, что переданное значение в метод находится
+        // в нужном диапазоне допустимых значений.
+        if (denomination < 2 || denomination > 14) {
+            // Вернуть ложь, если переданное значение некорректное
+            return false;
+        }
+        // Установить значение переданное в метод текущей карте
+        Denomination = denomination;
+        // Вернуть истину, если номинал установлен
+        return true;
+    }
+}

src/com/company/Dealler.java

@@ -0,0 +1,206 @@
+package com.company;
+
+import java.util.Random;
+
+public class Dealler {
+    private final Player []players;
+    private final Deck deck = new Deck();
+    private final Card [] table = new Card[5];
+    private int CardOnDesk = 0;
+    private RATE_TYPE currentRateType;
+    Random random = new Random(System.currentTimeMillis());
+
+    public Dealler(int playerCount) throws Exception {
+        if (playerCount < 2 || playerCount > 9) {
+            throw new Exception("Некорректное количество игроков!");
+        }
+
+        players = new Player[playerCount];
+
+        for (int i = 0; i < playerCount; i++) {
+            players[i] = new Player();
+        }
+
+        currentRateType = RATE_TYPE.PREFLOP;
+    }
+
+    public void HandOut() {
+        boolean isFirstCardOnHand = false;
+        switch (currentRateType) {
+            case PREFLOP: {
+                for (int i = 0; i < players.length; i++) {
+                    int cardIndex = random.nextInt(52);
+                    Card currentCard = deck.Cards[cardIndex];
+                    if (!isFirstCardOnHand) {
+                        if (currentCard.onHands) {
+                            i--;
+                            continue;
+                        }
+                        currentCard.onHands = true;
+                        players[i].setCards(PLAYER_CARD.FIRST, currentCard);
+                    }
+                    isFirstCardOnHand = true;
+                    cardIndex = random.nextInt(52);
+                    currentCard = deck.Cards[cardIndex];
+                    if (currentCard.onHands) {
+                        i--;
+                        continue;
+                    }
+                    currentCard.onHands = true;
+                    players[i].setCards(PLAYER_CARD.SECOND, currentCard);
+                    isFirstCardOnHand = false;
+                }
+                currentRateType = RATE_TYPE.FLOP;
+            } break;
+            case FLOP: {
+                PutOnDesk(3);
+                currentRateType = RATE_TYPE.TURN;
+            } break;
+            case TURN: {
+                PutOnDesk(1);
+                currentRateType = RATE_TYPE.RIVER;
+            } break;
+            case RIVER: {
+                PutOnDesk(1);
+                currentRateType = RATE_TYPE.OPENING;
+            } break;
+            case OPENING: {
+                OpeningCard();
+                CardOnDesk = 0;
+                currentRateType = RATE_TYPE.PREFLOP;
+            }
+        }
+    }
+
+    public void PutOnDesk(int cardCount) {
+        for (int i = 0; i < cardCount; i++) {
+            int cardIndex = random.nextInt(52);
+            Card currentCard = deck.Cards[cardIndex];
+            if (currentCard.onHands) {
+                i--;
+                continue;
+            }
+            table[CardOnDesk++] = currentCard;
+        }
+    }
+// ♦♣♥♠
+    public void OpeningCard() {
+        System.out.println("Карты на столе ");
+        for (Card card: table) {
+            System.out.print(
+                    deck.CardName.get(card.getDenomination())
+                            + Lear.SYMBOL[card.Lear.ordinal()] + " ");
+        }
+        System.out.println("\n\nКарты игроков");
+
+        for (Player player: players) {
+            Card []sharedCards = new Card[7];
+            int i = 0;
+            for (; i < table.length; i++) {
+                sharedCards[i] = table[i];
+            }
+            sharedCards[i++] = player.getCards(PLAYER_CARD.FIRST);
+            sharedCards[i] = player.getCards(PLAYER_CARD.SECOND);
+
+            try {
+                Sorting(sharedCards);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+            for (i = 0; i < sharedCards.length; i++) {
+                System.out.print(
+                        deck.CardName.get(sharedCards[i].getDenomination())
+                                + Lear.SYMBOL[sharedCards[i].Lear.ordinal()] + " ");
+            }
+            System.out.println();
+
+//            System.out.print(
+//                    deck.CardName.get(player.getCards(PLAYER_CARD.FIRST).getDenomination())
+//                            + Lear.SYMBOL[player.getCards(PLAYER_CARD.FIRST).Lear.ordinal()] + " "
+//            );
+//            System.out.println(
+//                    deck.CardName.get(player.getCards(PLAYER_CARD.SECOND).getDenomination())
+//                            + Lear.SYMBOL[player.getCards(PLAYER_CARD.SECOND).Lear.ordinal()] + " "
+//            );
+        }
+    }
+
+    /**
+     * Сортировка массива карт по убыванию его номинала
+     * @param cards массив карт (7 штук)
+     * @throws Exception
+     */
+    public void Sorting(Card[] cards) throws Exception {
+        if (cards.length != 7) {
+            throw new Exception("Что-то пошло не так");
+        }
+
+        for (int i = 0; i < cards.length; i++) {
+            for (int j = 0; j < cards.length - 1; j++) {
+                if (cards[j].getDenomination() < cards[j + 1].getDenomination()) {
+                    Card temp = cards[j];
+                    cards[j] = cards[j + 1];
+                    cards[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    /**
+     * Проверяет есть ли в переданном массиве комбинация Стрит
+     * @param cards массив карт
+     * @return true, если есть
+     */
+    public boolean isStreet(Card []cards) {
+        if (cards.length != 7) {
+            return false;
+        }
+
+        int counter = 0;
+        for (int i = 0; i < cards.length - 1; i++) {
+            if (counter == 5) {
+                return true;
+            }
+            if (cards[i].getDenomination() != cards[i + 1].getDenomination() + 1) {
+                break;
+            }
+
+            counter++;
+        }
+
+        return false;
+    }
+
+    public boolean isFlash(Card []cards, int cardCount) {
+        Lear.NAME currentLear;
+        int learCount = 0;
+
+        for (int i = 0; i < cardCount; i++) {
+            currentLear = cards[i].Lear;
+
+            for (int j = 0; j < cardCount; j++) {
+                if (i == j) {
+                    continue;
+                }
+
+                if (cards[j].Lear == currentLear) {
+                    learCount++;
+                }
+            }
+        }
+
+        return learCount >= 5;
+    }
+
+    public boolean isRoyalFlash(Card []cards) {
+        if (cards[0].getDenomination() != 14) {
+            return false;
+        }
+
+        return (isFlash(cards, 5) && isStreet(cards));
+    }
+}
+
+
+// A K Q J 10 все одной масти

src/com/company/Deck.java

@@ -0,0 +1,61 @@
+package com.company;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+
+/**
+ * Класс реализующий колоду
+ */
+public class Deck {
+    public final int CARD_COUNT = 52;
+
+    public Card Cards[] = new Card[CARD_COUNT];
+
+    Map<Integer, String> CardName = new HashMap<>();
+
+    /**
+     * Конструктор создает колоду карт
+     */
+    public Deck() {
+        for (int i = 0; i < CARD_COUNT; i++) {
+            Cards[i] = new Card();
+        }
+        Build();
+
+        CardName.put(2, "2");
+        CardName.put(3, "3");
+        CardName.put(4, "4");
+        CardName.put(5, "5");
+        CardName.put(6, "6");
+        CardName.put(7, "7");
+        CardName.put(8, "8");
+        CardName.put(9, "9");
+        CardName.put(10, "10");
+        CardName.put(11, "J");
+        CardName.put(12, "Q");
+        CardName.put(13, "K");
+        CardName.put(14, "A");
+    }
+
+    /**
+     * Метод генерирует колоду
+     */
+    public void Build() {
+        // Количество различных номиналов (для цикла от 2 до 14 включительно)
+        int denominationCount = (CARD_COUNT / 4) + 2;
+        // Счетчик всех карт (для прохода по массиву cards)
+        int cardCounter = 0;
+        // Цикл foreach (пройти по каджой масти)
+        for (Lear.NAME lear: Lear.NAME.values()) {
+            // Цикл по номиналам (от 2 до 14 включительно)
+            for (int j = 2; j < denominationCount; j++) {
+                // Записать текущую масть в карту с индексом cardCounter
+                Cards[cardCounter].Lear = lear;
+                // Записать текущий номинал в карту с индексом cardCounter
+                // и увеличить счетчик
+                Cards[cardCounter++].setDenomination(j);
+            }
+        }
+    }
+}

src/com/company/LEAR.java

@@ -0,0 +1,18 @@
+package com.company;
+
+
+
+class Lear {
+    /**
+     * Перечисление мастей карт
+     */
+    public enum NAME {
+        DIAMONDS,   // буби
+        HEARTS,     // черви
+        SPADES,     // пики
+        CLUBS,      // крести
+    }
+
+    public final static char []SYMBOL = new char[] {'♦','♥','♠','♣'};
+
+}

src/com/company/Main.java

@@ -0,0 +1,14 @@
+package com.company;
+
+public class Main {
+
+    public static void main(String[] args) throws Exception {
+
+        Dealler dealler = new Dealler(4);
+        dealler.HandOut();
+        dealler.HandOut();
+        dealler.HandOut();
+        dealler.HandOut();
+        dealler.HandOut();
+    }
+}

src/com/company/Player.java

@@ -0,0 +1,28 @@
+package com.company;
+
+/**
+ * Перечисление карт игрока.
+ * FIRST - первая карта (или 0)
+ * SECOND - вторая карта (или 1)
+ */
+enum PLAYER_CARD {
+    FIRST,
+    SECOND,
+}
+
+public class Player {
+    private final Card[] cards = new Card[2];
+
+    /**
+     * Установить карту в указанный слот
+     * @param slot
+     * @param card
+     */
+    public void setCards(PLAYER_CARD slot, Card card) {
+        cards[slot.ordinal()] = card;
+    }
+
+    public Card getCards(PLAYER_CARD slot) {
+        return cards[slot.ordinal()];
+    }
+}

src/com/company/RATE_TYPE.java

@@ -0,0 +1,12 @@
+package com.company;
+
+/**
+ * Типы ставок
+ */
+public enum RATE_TYPE {
+    PREFLOP,
+    FLOP,
+    TURN,
+    RIVER,
+    OPENING,
+}