chore(format): apply formatter (#69)

Author: juliankuecken

src/main/kotlin/hwr/oop/projects/peakpoker/core/card/CommunityCards.kt

@@ -16,12 +16,14 @@ class CommunityCards(
   /**
    * Exception thrown when the number of community cards is invalid
    */
-  class InvalidCardConfigurationException(message: String) : IllegalStateException(message)
+  class InvalidCardConfigurationException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when attempting to deal community cards in an invalid round phase
    */
-  class InvalidDealPhaseException(message: String) : IllegalStateException(message)
+  class InvalidDealPhaseException(message: String) :
+    IllegalStateException(message)
 
   init {
     if (cards.isNotEmpty() && cards.size !in listOf(3, 4, 5)) {

src/main/kotlin/hwr/oop/projects/peakpoker/core/card/HoleCards.kt

@@ -6,25 +6,26 @@ import kotlinx.serialization.Transient
 
 @Serializable
 class HoleCards(
-    val cards: List<Card>,
-    @Transient val player: PokerPlayer? = null,
+  val cards: List<Card>,
+  @Transient val player: PokerPlayer? = null,
 ) : Iterable<Card> by cards {
-    /**
-     * Exception thrown when duplicate cards are found in the hole cards
-     */
-    class DuplicateCardException(message: String) : IllegalStateException(message)
+  /**
+   * Exception thrown when duplicate cards are found in the hole cards
+   */
+  class DuplicateCardException(message: String) : IllegalStateException(message)
 
-    /**
-     * Exception thrown when the number of hole cards is invalid
-     */
-    class InvalidCardConfigurationException(message: String) : IllegalStateException(message)
+  /**
+   * Exception thrown when the number of hole cards is invalid
+   */
+  class InvalidCardConfigurationException(message: String) :
+    IllegalStateException(message)
 
-    init {
-        if (cards.isNotEmpty() && cards.size != 2) {
-            throw InvalidCardConfigurationException("Hole cards must be empty or contain exactly two cards.")
-        }
-        if (cards.distinct().size != cards.size) {
-            throw DuplicateCardException("Hole cards must not contain duplicates.")
-        }
+  init {
+    if (cards.isNotEmpty() && cards.size != 2) {
+      throw InvalidCardConfigurationException("Hole cards must be empty or contain exactly two cards.")
     }
+    if (cards.distinct().size != cards.size) {
+      throw DuplicateCardException("Hole cards must not contain duplicates.")
+    }
+  }
 }

src/main/kotlin/hwr/oop/projects/peakpoker/core/card/Rank.kt

@@ -4,19 +4,19 @@ import kotlinx.serialization.Serializable
 
 @Serializable
 enum class Rank(
-    val value: Int,
+  val value: Int,
 ) {
-    TWO(1),
-    THREE(2),
-    FOUR(3),
-    FIVE(4),
-    SIX(5),
-    SEVEN(6),
-    EIGHT(7),
-    NINE(8),
-    TEN(9),
-    JACK(10),
-    QUEEN(11),
-    KING(12),
-    ACE(13)
+  TWO(1),
+  THREE(2),
+  FOUR(3),
+  FIVE(4),
+  SIX(5),
+  SEVEN(6),
+  EIGHT(7),
+  NINE(8),
+  TEN(9),
+  JACK(10),
+  QUEEN(11),
+  KING(12),
+  ACE(13)
 }

src/main/kotlin/hwr/oop/projects/peakpoker/core/card/Suit.kt

@@ -4,5 +4,5 @@ import kotlinx.serialization.Serializable
 
 @Serializable
 enum class Suit {
-    HEARTS, DIAMONDS, CLUBS, SPADES
+  HEARTS, DIAMONDS, CLUBS, SPADES
 }

src/main/kotlin/hwr/oop/projects/peakpoker/core/deck/Deck.kt

@@ -11,7 +11,8 @@ class Deck() {
   /**
    * Thrown when trying to draw more cards than are available in the deck
    */
-  class InsufficientCardsException(message: String) : IllegalStateException(message)
+  class InsufficientCardsException(message: String) :
+    IllegalStateException(message)
 
   // Create a list of all possible cards and shuffle it right away
   @Transient

src/main/kotlin/hwr/oop/projects/peakpoker/core/game/PokerGame.kt

@@ -13,17 +13,20 @@ class PokerGame(
   /**
    * Exception thrown when duplicate player names are found
    */
-  class DuplicatePlayerException(message: String) : IllegalStateException(message)
+  class DuplicatePlayerException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when blind configuration is invalid
    */
-  class InvalidBlindConfigurationException(message: String) : IllegalStateException(message)
+  class InvalidBlindConfigurationException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when there are not enough players
    */
-  class MinimumPlayersException(message: String) : IllegalStateException(message)
+  class MinimumPlayersException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when trying to access a round when none is active

src/main/kotlin/hwr/oop/projects/peakpoker/core/game/PokerRound.kt

@@ -20,37 +20,44 @@ class PokerRound(
   /**
    * Exception thrown when a player attempts a betting action without sufficient chips
    */
-  class InsufficientChipsForBettingException(message: String) : IllegalStateException(message)
+  class InsufficientChipsForBettingException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Thrown when an action is attempted on a player in an invalid state
    */
-  class InvalidPlayerStateException(message: String) : IllegalStateException(message)
+  class InvalidPlayerStateException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when a bet amount violates poker betting rules
    */
-  class InvalidBetAmountException(message: String) : IllegalStateException(message)
+  class InvalidBetAmountException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when a player attempts an invalid call action
    */
-  class InvalidCallActionException(message: String) : IllegalStateException(message)
+  class InvalidCallActionException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when a player attempts an invalid check action
    */
-  class InvalidCheckActionException(message: String) : IllegalStateException(message)
+  class InvalidCheckActionException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when a player with a specified name is not found in the game
    */
-  class PlayerNotFoundException(message: String) : IllegalStateException(message)
+  class PlayerNotFoundException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when an invalid operation is attempted for the current round phase
    */
-  class IllegalRoundPhaseException(message: String) : IllegalStateException(message)
+  class IllegalRoundPhaseException(message: String) :
+    IllegalStateException(message)
 
   @Transient
   private var onRoundComplete: () -> Unit =

src/main/kotlin/hwr/oop/projects/peakpoker/core/hand/HandEvaluator.kt

@@ -13,17 +13,20 @@ class HandEvaluator(
   /**
    * Exception thrown when an empty player list is provided
    */
-  class EmptyPlayerListEvaluationException(message: String) : IllegalArgumentException(message)
+  class EmptyPlayerListEvaluationException(message: String) :
+    IllegalArgumentException(message)
 
   /**
    * Exception thrown when an invalid number of cards is found
    */
-  class InvalidCardCountException(message: String) : IllegalArgumentException(message)
+  class InvalidCardCountException(message: String) :
+    IllegalArgumentException(message)
 
   /**
    * Exception thrown when no valid hand can be found
    */
-  class NoValidHandFoundException(message: String) : IllegalStateException(message)
+  class NoValidHandFoundException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Determines all players with the highest hand among a list of players.

src/main/kotlin/hwr/oop/projects/peakpoker/core/player/PokerPlayer.kt

@@ -11,17 +11,20 @@ class PokerPlayer(
   /**
    * Exception thrown when attempting to create a player with negative chips balance
    */
-  class InvalidInitialChipsBalanceException(message: String) : IllegalStateException(message)
+  class InvalidInitialChipsBalanceException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when a player name is invalid
    */
-  class InvalidPlayerNameException(message: String) : IllegalStateException(message)
+  class InvalidPlayerNameException(message: String) :
+    IllegalStateException(message)
 
   /**
    * Exception thrown when performing an invalid betting operation
    */
-  class InvalidBetOperationException(message: String) : IllegalStateException(message)
+  class InvalidBetOperationException(message: String) :
+    IllegalStateException(message)
 
 
   init {

src/main/kotlin/hwr/oop/projects/peakpoker/core/pot/PokerPots.kt

@@ -6,83 +6,83 @@ import kotlinx.serialization.Serializable
 
 @Serializable
 class PokerPots(
-    private val players: List<PokerPlayer>,
-    private val communityCards: CommunityCards,
-    val pots: MutableList<Pot> =
-        mutableListOf(
-            Pot(
-                eligiblePlayers = players.toSet(),
-                communityCards = communityCards
-            )
-        ),
+  private val players: List<PokerPlayer>,
+  private val communityCards: CommunityCards,
+  val pots: MutableList<Pot> =
+    mutableListOf(
+      Pot(
+        eligiblePlayers = players.toSet(),
+        communityCards = communityCards
+      )
+    ),
 ) : Iterable<Pot> by pots {
-    private val mainPot: Pot get() = pots.first()
+  private val mainPot: Pot get() = pots.first()
 
-    fun addChipsToCurrentPot(chips: Int) {
-        mainPot.addChips(chips)
-    }
-
-    /**
-     * Creates a side pot when a player goes all-in.
-     *
-     * This method:
-     * 1. Calculates excess chips from other players (amounts above what the all-in player could match)
-     * 2. Reduces those players' bets to match the all-in amount
-     * 3. Moves excess chips from the main pot to a new side pot
-     * 4. Makes the all-in player ineligible for the side pot
-     *
-     * @param allInPlayer The player who has gone all-in
-     */
-    fun createSidePotIfNeeded(allInPlayer: PokerPlayer) {
-        val excessAmount = calculateExcessAmount(allInPlayer)
+  fun addChipsToCurrentPot(chips: Int) {
+    mainPot.addChips(chips)
+  }
 
-        // If no excess chips, no need for a side pot
-        if (excessAmount <= 0) return
+  /**
+   * Creates a side pot when a player goes all-in.
+   *
+   * This method:
+   * 1. Calculates excess chips from other players (amounts above what the all-in player could match)
+   * 2. Reduces those players' bets to match the all-in amount
+   * 3. Moves excess chips from the main pot to a new side pot
+   * 4. Makes the all-in player ineligible for the side pot
+   *
+   * @param allInPlayer The player who has gone all-in
+   */
+  fun createSidePotIfNeeded(allInPlayer: PokerPlayer) {
+    val excessAmount = calculateExcessAmount(allInPlayer)
 
-        // If there are excess chips, move them to a side pot
+    // If no excess chips, no need for a side pot
+    if (excessAmount <= 0) return
 
-        // Reduce the main pot by the excess amount
-        mainPot.removeChips(excessAmount)
+    // If there are excess chips, move them to a side pot
 
-        // Create a side pot with eligible players (everyone but the all-in player)
-        val eligiblePlayers =
-            mainPot.eligiblePlayers.filter { it != allInPlayer }.toSet()
-        pots.add(
-            Pot(
-                eligiblePlayers = eligiblePlayers,
-                communityCards = communityCards,
-                amount = excessAmount
-            )
-        )
-    }
+    // Reduce the main pot by the excess amount
+    mainPot.removeChips(excessAmount)
 
-    /**
-     * Calculates the excess amount of chips that should be moved to a side pot when a player goes all-in.
-     *
-     * This method:
-     * 1. Determines the total amount the all-in player can bet (current bet and remaining chips)
-     * 2. Identifies players who have bet more than this amount
-     * 3. Calculates the total excess chips from these players
-     * 4. Adjusts these players' bets to match the all-in amount
-     *
-     * @param allInPlayer The player who has gone all-in
-     * @return The total excess amount that should be moved to a side pot
-     */
-    private fun calculateExcessAmount(allInPlayer: PokerPlayer): Int {
-        // Get all-in amount (player's bet and remaining chips)
-        val allInTotal = allInPlayer.bet() + allInPlayer.chips()
+    // Create a side pot with eligible players (everyone but the all-in player)
+    val eligiblePlayers =
+      mainPot.eligiblePlayers.filter { it != allInPlayer }.toSet()
+    pots.add(
+      Pot(
+        eligiblePlayers = eligiblePlayers,
+        communityCards = communityCards,
+        amount = excessAmount
+      )
+    )
+  }
 
-        // Calculate excess chips from other players
-        var excessAmount = 0
-        players.forEach { player ->
-            if (!player.isFolded() && player != allInPlayer && player.bet() > allInTotal) {
-                val excess = player.bet() - allInTotal
-                excessAmount += excess
-                // Adjust player's bet to match all-in
-                player.setBetAmount(allInTotal)
-            }
-        }
+  /**
+   * Calculates the excess amount of chips that should be moved to a side pot when a player goes all-in.
+   *
+   * This method:
+   * 1. Determines the total amount the all-in player can bet (current bet and remaining chips)
+   * 2. Identifies players who have bet more than this amount
+   * 3. Calculates the total excess chips from these players
+   * 4. Adjusts these players' bets to match the all-in amount
+   *
+   * @param allInPlayer The player who has gone all-in
+   * @return The total excess amount that should be moved to a side pot
+   */
+  private fun calculateExcessAmount(allInPlayer: PokerPlayer): Int {
+    // Get all-in amount (player's bet and remaining chips)
+    val allInTotal = allInPlayer.bet() + allInPlayer.chips()
 
-        return excessAmount
+    // Calculate excess chips from other players
+    var excessAmount = 0
+    players.forEach { player ->
+      if (!player.isFolded() && player != allInPlayer && player.bet() > allInTotal) {
+        val excess = player.bet() - allInTotal
+        excessAmount += excess
+        // Adjust player's bet to match all-in
+        player.setBetAmount(allInTotal)
+      }
     }
+
+    return excessAmount
+  }
 }