backend/src/main/java/de/szut/casino/blackjack/BlackJackGameController.java

@@ -94,23 +94,6 @@ public class BlackJackGameController {
         return ResponseEntity.ok(blackJackService.doubleDown(game));
     }
 
-    @PostMapping("/blackjack/{id}/split")
-    public ResponseEntity<Object> split(@PathVariable Long id, @RequestHeader("Authorization") String token) {
-        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
-
-        if (optionalUser.isEmpty()) {
-            return ResponseEntity.notFound().build();
-        }
-
-        UserEntity user = optionalUser.get();
-        BlackJackGameEntity game = blackJackService.getBlackJackGame(id);
-        if (game == null || !Objects.equals(game.getUserId(), user.getId())) {
-            return ResponseEntity.notFound().build();
-        }
-
-        return ResponseEntity.ok(blackJackService.split(game));
-    }
-
     @PostMapping("/blackjack/start")
     public ResponseEntity<Object> createBlackJackGame(@RequestBody @Valid CreateBlackJackGameDto createBlackJackGameDto, @RequestHeader("Authorization") String token) {
         Optional<UserEntity> optionalUser = userService.getCurrentUser(token);

backend/src/main/java/de/szut/casino/blackjack/BlackJackGameEntity.java

@@ -51,15 +51,4 @@ public class BlackJackGameEntity {
     @JsonManagedReference
     @SQLRestriction("card_type = 'DEALER'")
     private List<CardEntity> dealerCards = new ArrayList<>();
-
-    @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, orphanRemoval = true)
-    @JsonManagedReference
-    @SQLRestriction("card_type = 'PLAYER_SPLIT'")
-    private List<CardEntity> playerSplitCards = new ArrayList<>();
-
-    @Column(name = "split_bet")
-    private BigDecimal splitBet;
-
-    @Column(name = "is_split")
-    private boolean isSplit;
 }

backend/src/main/java/de/szut/casino/blackjack/BlackJackService.java

@@ -1,314 +1,245 @@
-package de.szut.casino.blackjack;
+package de.szut.casino.blackjack;
-
+
-import de.szut.casino.user.UserEntity;
+import de.szut.casino.user.UserEntity;
-import de.szut.casino.user.UserRepository;
+import de.szut.casino.user.UserRepository;
-import org.springframework.stereotype.Service;
+import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.annotation.Transactional;
-
+
-import java.math.BigDecimal;
+import java.math.BigDecimal;
-import java.util.List;
+import java.util.List;
-import java.util.Optional;
+import java.util.Optional;
-import java.util.Random;
+import java.util.Random;
-
+
-@Service
+@Service
-public class BlackJackService {
+public class BlackJackService {
-    private final BlackJackGameRepository blackJackGameRepository;
+    private final BlackJackGameRepository blackJackGameRepository;
-    private final UserRepository userRepository;
+    private final UserRepository userRepository;
-    private final Random random = new Random();
+    private final Random random = new Random();
-
+
-    public BlackJackService(BlackJackGameRepository blackJackGameRepository, UserRepository userRepository) {
+    public BlackJackService(BlackJackGameRepository blackJackGameRepository, UserRepository userRepository) {
-        this.blackJackGameRepository = blackJackGameRepository;
+        this.blackJackGameRepository = blackJackGameRepository;
-        this.userRepository = userRepository;
+        this.userRepository = userRepository;
-    }
+    }
-
+
-    public BlackJackGameEntity getBlackJackGame(Long id) {
+    public BlackJackGameEntity getBlackJackGame(Long id) {
-        return blackJackGameRepository.findById(id).orElse(null);
+        return blackJackGameRepository.findById(id).orElse(null);
-    }
+    }
-
+
-    @Transactional
+    @Transactional
-    public BlackJackGameEntity createBlackJackGame(UserEntity user, BigDecimal betAmount) {
+    public BlackJackGameEntity createBlackJackGame(UserEntity user, BigDecimal betAmount) {
-        BlackJackGameEntity game = new BlackJackGameEntity();
+        BlackJackGameEntity game = new BlackJackGameEntity();
-        game.setUser(user);
+        game.setUser(user);
-        game.setBet(betAmount);
+        game.setBet(betAmount);
-        
+        
-        initializeDeck(game);
+        initializeDeck(game);
-        dealInitialCards(game);
+        dealInitialCards(game);
-        
+        
-        game.setState(getState(game));
+        game.setState(getState(game));
-        deductBetFromBalance(user, betAmount);
+        deductBetFromBalance(user, betAmount);
-        
+        
-        return blackJackGameRepository.save(game);
+        return blackJackGameRepository.save(game);
-    }
+    }
-
+
-    @Transactional
+    @Transactional
-    public BlackJackGameEntity hit(BlackJackGameEntity game) {
+    public BlackJackGameEntity hit(BlackJackGameEntity game) {
-        if (game.getState() != BlackJackState.IN_PROGRESS) {
+        game = refreshGameState(game);
-            return game;
+        
-        }
+        if (game.getState() != BlackJackState.IN_PROGRESS) {
-        
+            return game;
-        dealCardToPlayer(game);
+        }
-        
+        
-        updateGameStateAndBalance(game);
+        dealCardToPlayer(game);
-        
+        updateGameStateAndBalance(game);
-        return blackJackGameRepository.save(game);
+        
-    }
+        return blackJackGameRepository.save(game);
-
+    }
-    @Transactional
+
-    public BlackJackGameEntity stand(BlackJackGameEntity game) {
+    @Transactional
-        if (game.getState() != BlackJackState.IN_PROGRESS) {
+    public BlackJackGameEntity stand(BlackJackGameEntity game) {
-            return game;
+        game = refreshGameState(game);
-        }
+        
-        
+        if (game.getState() != BlackJackState.IN_PROGRESS) {
-        dealCardsToDealerUntilMinimumScore(game);
+            return game;
-        determineWinnerAndUpdateBalance(game);
+        }
-        
+        
-        return blackJackGameRepository.save(game);
+        dealCardsToDealerUntilMinimumScore(game);
-    }
+        determineWinnerAndUpdateBalance(game);
-
+        
-    @Transactional
+        return blackJackGameRepository.save(game);
-    public BlackJackGameEntity doubleDown(BlackJackGameEntity game) {
+    }
-        if (game.getState() != BlackJackState.IN_PROGRESS || game.getPlayerCards().size() != 2) {
+
-            return game;
+    @Transactional
-        }
+    public BlackJackGameEntity doubleDown(BlackJackGameEntity game) {
-        
+        game = refreshGameState(game);
-        UserEntity user = getUserWithFreshData(game.getUser());
+        
-        BigDecimal additionalBet = game.getBet();
+        if (game.getState() != BlackJackState.IN_PROGRESS || game.getPlayerCards().size() != 2) {
-        
+            return game;
-        if (user.getBalance().compareTo(additionalBet) < 0) {
+        }
-            return game;
+        
-        }
+        UserEntity user = getUserWithFreshData(game.getUser());
-        
+        BigDecimal additionalBet = game.getBet();
-        deductBetFromBalance(user, additionalBet);
+        
-        game.setBet(game.getBet().add(additionalBet));
+        if (user.getBalance().compareTo(additionalBet) < 0) {
-        
+            return game;
-        dealCardToPlayer(game);
+        }
-        updateGameStateAndBalance(game);
+        
-        
+        deductBetFromBalance(user, additionalBet);
-        if (game.getState() == BlackJackState.IN_PROGRESS) {
+        game.setBet(game.getBet().add(additionalBet));
-            return stand(game);
+        
-        }
+        dealCardToPlayer(game);
-        
+        updateGameStateAndBalance(game);
-        return game;
+        
-    }
+        if (game.getState() == BlackJackState.IN_PROGRESS) {
-
+            return stand(game);
-    @Transactional
+        }
-    public BlackJackGameEntity split(BlackJackGameEntity game) {
+        
-        if (game.getState() != BlackJackState.IN_PROGRESS || 
+        return game;
-            game.getPlayerCards().size() != 2 || 
+    }
-            game.isSplit() ||
+
-            !game.getPlayerCards().get(0).getRank().equals(game.getPlayerCards().get(1).getRank())) {
+    private BlackJackGameEntity refreshGameState(BlackJackGameEntity game) {
-            return game;
+        return blackJackGameRepository.findById(game.getId()).orElse(game);
-        }
+    }
-        
+    
-        UserEntity user = getUserWithFreshData(game.getUser());
+    private UserEntity getUserWithFreshData(UserEntity user) {
-        BigDecimal splitBet = game.getBet();
+        return userRepository.findById(user.getId()).orElse(user);
-        
+    }
-        if (user.getBalance().compareTo(splitBet) < 0) {
+    
-            return game;
+    private void dealInitialCards(BlackJackGameEntity game) {
-        }
+        for (int i = 0; i < 2; i++) {
-        
+            dealCardToPlayer(game);
-        deductBetFromBalance(user, splitBet);
+        }
-        game.setSplitBet(splitBet);
+        
-        game.setSplit(true);
+        dealCardToDealer(game);
-        
+    }
-        CardEntity card = game.getPlayerCards().remove(1);
+    
-        card.setCardType(CardType.PLAYER_SPLIT);
+    private void dealCardToPlayer(BlackJackGameEntity game) {
-        game.getPlayerSplitCards().add(card);
+        CardEntity card = drawCardFromDeck(game);
-        
+        card.setCardType(CardType.PLAYER);
-        dealCardToPlayer(game);
+        game.getPlayerCards().add(card);
-        dealCardToSplitHand(game);
+    }
-        
+    
-        return blackJackGameRepository.save(game);
+    private void dealCardToDealer(BlackJackGameEntity game) {
-    }
+        CardEntity card = drawCardFromDeck(game);
-
+        card.setCardType(CardType.DEALER);
-    private BlackJackGameEntity refreshGameState(BlackJackGameEntity game) {
+        game.getDealerCards().add(card);
-        return blackJackGameRepository.findById(game.getId()).orElse(game);
+    }
-    }
+    
-    
+    private void dealCardsToDealerUntilMinimumScore(BlackJackGameEntity game) {
-    private UserEntity getUserWithFreshData(UserEntity user) {
+        while (calculateHandValue(game.getDealerCards()) < 17) {
-        return userRepository.findById(user.getId()).orElse(user);
+            dealCardToDealer(game);
-    }
+        }
-    
+    }
-    private void dealInitialCards(BlackJackGameEntity game) {
+    
-        for (int i = 0; i < 2; i++) {
+    private void updateGameStateAndBalance(BlackJackGameEntity game) {
-            dealCardToPlayer(game);
+        game.setState(getState(game));
-        }
+        
-        
+        if (game.getState() == BlackJackState.PLAYER_WON) {
-        dealCardToDealer(game);
+            updateUserBalance(game, true);
-    }
+        } else if (game.getState() == BlackJackState.PLAYER_LOST) {
-    
+            updateUserBalance(game, false);
-    private void dealCardToPlayer(BlackJackGameEntity game) {
+        }
-        CardEntity card = drawCardFromDeck(game);
+    }
-        card.setCardType(CardType.PLAYER);
+    
-        game.getPlayerCards().add(card);
+    private void determineWinnerAndUpdateBalance(BlackJackGameEntity game) {
-    }
+        int playerValue = calculateHandValue(game.getPlayerCards());
-    
+        int dealerValue = calculateHandValue(game.getDealerCards());
-    private void dealCardToDealer(BlackJackGameEntity game) {
+
-        CardEntity card = drawCardFromDeck(game);
+        if (dealerValue > 21 || playerValue > dealerValue) {
-        card.setCardType(CardType.DEALER);
+            game.setState(BlackJackState.PLAYER_WON);
-        game.getDealerCards().add(card);
+            updateUserBalance(game, true);
-    }
+        } else if (playerValue < dealerValue) {
-    
+            game.setState(BlackJackState.PLAYER_LOST);
-    private void dealCardsToDealerUntilMinimumScore(BlackJackGameEntity game) {
+            updateUserBalance(game, false);
-        while (calculateHandValue(game.getDealerCards()) < 17) {
+        } else {
-            dealCardToDealer(game);
+            game.setState(BlackJackState.DRAW);
-        }
+            updateUserBalance(game, false); // For draw, player gets their bet back
-    }
+        }
-    
+    }
-    private void dealCardToSplitHand(BlackJackGameEntity game) {
+    
-        CardEntity card = drawCardFromDeck(game);
+    private void deductBetFromBalance(UserEntity user, BigDecimal betAmount) {
-        card.setCardType(CardType.PLAYER_SPLIT);
+        user.setBalance(user.getBalance().subtract(betAmount));
-        game.getPlayerSplitCards().add(card);
+        userRepository.save(user);
-    }
+    }
-    
+
-    private void updateGameStateAndBalance(BlackJackGameEntity game) {
+    @Transactional
-        if (game.isSplit()) {
+    private void updateUserBalance(BlackJackGameEntity game, boolean isWin) {
-            int mainHandValue = calculateHandValue(game.getPlayerCards());
+        UserEntity user = getUserWithFreshData(game.getUser());
-            int splitHandValue = calculateHandValue(game.getPlayerSplitCards());
+        BigDecimal betAmount = game.getBet();
-            
+        BigDecimal balance = user.getBalance();
-            if (mainHandValue > 21 && splitHandValue > 21) {
+        
-                game.setState(BlackJackState.PLAYER_LOST);
+        if (isWin) {
-                updateUserBalance(game, false);
+            balance = balance.add(betAmount.multiply(BigDecimal.valueOf(2)));
-            } else if (mainHandValue <= 21 && splitHandValue <= 21) {
+        } else if (game.getState() == BlackJackState.DRAW) {
-                game.setState(BlackJackState.IN_PROGRESS);
+            balance = balance.add(betAmount);
-            } else {
+        }
-                game.setState(BlackJackState.IN_PROGRESS);
+        
-            }
+        user.setBalance(balance);
-        } else {
+        userRepository.save(user);
-            game.setState(getState(game));
+    }
-            
+
-            if (game.getState() == BlackJackState.PLAYER_WON) {
+    private void initializeDeck(BlackJackGameEntity game) {
-                updateUserBalance(game, true);
+        for (Suit suit : Suit.values()) {
-            } else if (game.getState() == BlackJackState.PLAYER_LOST) {
+            for (Rank rank : Rank.values()) {
-                updateUserBalance(game, false);
+                CardEntity card = new CardEntity();
-            }
+                card.setGame(game);
-        }
+                card.setSuit(suit);
-    }
+                card.setRank(rank);
-    
+                card.setCardType(CardType.DECK);
-    private void determineWinnerAndUpdateBalance(BlackJackGameEntity game) {
+                game.getDeck().add(card);
-        int playerValue = calculateHandValue(game.getPlayerCards());
+            }
-        int dealerValue = calculateHandValue(game.getDealerCards());
+        }
-
+
-        if (dealerValue > 21 || playerValue > dealerValue) {
+        java.util.Collections.shuffle(game.getDeck(), random);
-            game.setState(BlackJackState.PLAYER_WON);
+    }
-            updateUserBalance(game, true);
+
-        } else if (playerValue < dealerValue) {
+    private CardEntity drawCardFromDeck(BlackJackGameEntity game) {
-            game.setState(BlackJackState.PLAYER_LOST);
+        if (game.getDeck().isEmpty()) {
-            updateUserBalance(game, false);
+            throw new IllegalStateException("Deck is empty");
-        } else {
+        }
-            game.setState(BlackJackState.DRAW);
+
-            updateUserBalance(game, false);
+        return game.getDeck().removeFirst();
-        }
+    }
-    }
+
-    
+    private BlackJackState getState(BlackJackGameEntity game) {
-    private void deductBetFromBalance(UserEntity user, BigDecimal betAmount) {
+        int playerHandValue = calculateHandValue(game.getPlayerCards());
-        user.setBalance(user.getBalance().subtract(betAmount));
+
-        userRepository.save(user);
+        if (playerHandValue == 21) {
-    }
+            CardEntity hole = drawCardFromDeck(game);
-
+            hole.setCardType(CardType.DEALER);
-    @Transactional
+            game.getDealerCards().add(hole);
-    private void updateUserBalance(BlackJackGameEntity game, boolean isWin) {
+
-        UserEntity user = getUserWithFreshData(game.getUser());
+            int dealerHandValue = calculateHandValue(game.getDealerCards());
-        BigDecimal totalBet = game.getBet();
+
-        BigDecimal balance = user.getBalance();
+            if (dealerHandValue == 21) {
-        
+                return BlackJackState.DRAW;
-        if (game.isSplit()) {
+            } else {
-            totalBet = totalBet.add(game.getSplitBet());
+                BigDecimal blackjackWinnings = game.getBet().multiply(new BigDecimal("1.5"));
-            
+                UserEntity user = getUserWithFreshData(game.getUser());
-            if (isWin) {
+                user.setBalance(user.getBalance().add(blackjackWinnings));
-                int mainHandValue = calculateHandValue(game.getPlayerCards());
+                return BlackJackState.PLAYER_BLACKJACK;
-                int splitHandValue = calculateHandValue(game.getPlayerSplitCards());
+            }
-                int dealerValue = calculateHandValue(game.getDealerCards());
+        } else if (playerHandValue > 21) {
-                
+            return BlackJackState.PLAYER_LOST;
-                if (mainHandValue <= 21 && (dealerValue > 21 || mainHandValue > dealerValue)) {
+        }
-                    balance = balance.add(game.getBet().multiply(BigDecimal.valueOf(2)));
+
-                } else if (mainHandValue == dealerValue) {
+        return BlackJackState.IN_PROGRESS;
-                    balance = balance.add(game.getBet());
+    }
-                }
+
-                
+    private int calculateHandValue(List<CardEntity> hand) {
-                if (splitHandValue <= 21 && (dealerValue > 21 || splitHandValue > dealerValue)) {
+        int sum = 0;
-                    balance = balance.add(game.getSplitBet().multiply(BigDecimal.valueOf(2)));
+        int aceCount = 0;
-                } else if (splitHandValue == dealerValue) {
+        for (CardEntity card : hand) {
-                    balance = balance.add(game.getSplitBet());
+            sum += card.getRank().getValue();
-                }
+            if (card.getRank() == Rank.ACE) {
-            } else if (game.getState() == BlackJackState.DRAW) {
+                aceCount++;
-                balance = balance.add(totalBet);
+            }
-            }
+        }
-        } else {
+
-            if (isWin) {
+        while (sum > 21 && aceCount > 0) {
-                balance = balance.add(totalBet.multiply(BigDecimal.valueOf(2)));
+            sum -= 10;
-            } else if (game.getState() == BlackJackState.DRAW) {
+            aceCount--;
-                balance = balance.add(totalBet);
+        }
-            }
+
-        }
+        return sum;
-        
+    }
-        user.setBalance(balance);
+}
-        userRepository.save(user);
-    }
-
-    private void initializeDeck(BlackJackGameEntity game) {
-        for (Suit suit : Suit.values()) {
-            for (Rank rank : Rank.values()) {
-                CardEntity card = new CardEntity();
-                card.setGame(game);
-                card.setSuit(suit);
-                card.setRank(rank);
-                card.setCardType(CardType.DECK);
-                game.getDeck().add(card);
-            }
-        }
-
-        java.util.Collections.shuffle(game.getDeck(), random);
-    }
-
-    private CardEntity drawCardFromDeck(BlackJackGameEntity game) {
-        if (game.getDeck().isEmpty()) {
-            throw new IllegalStateException("Deck is empty");
-        }
-
-        return game.getDeck().removeFirst();
-    }
-
-    private BlackJackState getState(BlackJackGameEntity game) {
-        int playerHandValue = calculateHandValue(game.getPlayerCards());
-
-        if (playerHandValue == 21) {
-            CardEntity hole = drawCardFromDeck(game);
-            hole.setCardType(CardType.DEALER);
-            game.getDealerCards().add(hole);
-
-            int dealerHandValue = calculateHandValue(game.getDealerCards());
-
-            if (dealerHandValue == 21) {
-                return BlackJackState.DRAW;
-            } else {
-                BigDecimal blackjackWinnings = game.getBet().multiply(new BigDecimal("1.5"));
-                UserEntity user = getUserWithFreshData(game.getUser());
-                user.setBalance(user.getBalance().add(blackjackWinnings));
-                return BlackJackState.PLAYER_BLACKJACK;
-            }
-        } else if (playerHandValue > 21) {
-            return BlackJackState.PLAYER_LOST;
-        }
-
-        return BlackJackState.IN_PROGRESS;
-    }
-
-    private int calculateHandValue(List<CardEntity> hand) {
-        int sum = 0;
-        int aceCount = 0;
-        for (CardEntity card : hand) {
-            sum += card.getRank().getValue();
-            if (card.getRank() == Rank.ACE) {
-                aceCount++;
-            }
-        }
-
-        while (sum > 21 && aceCount > 0) {
-            sum -= 10;
-            aceCount--;
-        }
-
-        return sum;
-    }
-}

backend/src/main/java/de/szut/casino/blackjack/CardEntity.java

@@ -36,5 +36,5 @@ public class CardEntity {
 }
 
 enum CardType {
-    DECK, PLAYER, DEALER, PLAYER_SPLIT
+    DECK, PLAYER, DEALER
 }

frontend/src/app/feature/game/blackjack/blackjack.component.ts

@@ -1,4 +1,4 @@
-import { ChangeDetectionStrategy, Component, inject, signal, OnInit } from '@angular/core';
+import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { Router } from '@angular/router';
 import { PlayingCardComponent } from './components/playing-card/playing-card.component';
@@ -13,7 +13,6 @@ import { GameResultComponent } from '@blackjack/components/game-result/game-resu
 import { GameState } from '@blackjack/enum/gameState';
 import { NavbarComponent } from '@shared/components/navbar/navbar.component';
 import { UserService } from '@service/user.service';
-import { timer } from 'rxjs';
 
 @Component({
   selector: 'app-blackjack',
@@ -31,7 +30,7 @@ import { timer } from 'rxjs';
   templateUrl: './blackjack.component.html',
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
-export default class BlackjackComponent implements OnInit {
+export default class BlackjackComponent {
   private router = inject(Router);
   private userService = inject(UserService);
   private blackjackService = inject(BlackjackService);
@@ -48,11 +47,13 @@ export default class BlackjackComponent implements OnInit {
   isActionInProgress = signal(false);
   currentAction = signal<string>('');
 
-  ngOnInit(): void {
+  constructor() {
-    this.userService.currentUser$.subscribe((user) => {
+    this.refreshUserBalance();
-      if (user) {
+  }
-        this.balance.set(user.balance);
+
-      }
+  private refreshUserBalance(): void {
+    this.userService.getCurrentUser().subscribe((user) => {
+      this.balance.set(user?.balance ?? 0);
     });
   }
 
@@ -82,10 +83,8 @@ export default class BlackjackComponent implements OnInit {
     if (isGameOver) {
       console.log('Game is over, state:', game.state);
       this.userService.refreshCurrentUser();
-      timer(1500).subscribe(() => {
+      this.showGameResult.set(true);
-        this.showGameResult.set(true);
+      console.log('Game result dialog should be shown now');
-        console.log('Game result dialog shown after delay');
-      });
     }
   }
 
@@ -181,18 +180,21 @@ export default class BlackjackComponent implements OnInit {
   onCloseGameResult(): void {
     console.log('Closing game result dialog');
     this.showGameResult.set(false);
-    this.userService.refreshCurrentUser();
   }
 
   private handleGameError(error: HttpErrorResponse): void {
     if (error instanceof HttpErrorResponse) {
       if (error.status === 400 && error.error?.error === 'Invalid state') {
         this.gameInProgress.set(false);
-        this.userService.refreshCurrentUser();
+
+        this.refreshUserBalance();
       } else if (error.status === 500) {
         console.log('Server error occurred. The game may have been updated in another session.');
+
         this.gameInProgress.set(false);
-        this.userService.refreshCurrentUser();
+
+        this.refreshUserBalance();
+
         if (this.currentGameId()) {
           this.refreshGameState(this.currentGameId()!);
         }

frontend/src/app/feature/game/blackjack/components/game-info/game-info.component.ts

@@ -6,11 +6,9 @@ import {
   OnChanges,
   Output,
   SimpleChanges,
-  signal,
 } from '@angular/core';
 import { CommonModule, CurrencyPipe } from '@angular/common';
-import { FormGroup, ReactiveFormsModule } from '@angular/forms';
+import { FormBuilder, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
-import { BettingService } from '@blackjack/services/betting.service';
 
 @Component({
   selector: 'app-game-info',
@@ -67,12 +65,10 @@ import { BettingService } from '@blackjack/services/betting.service';
               type="number"
               id="bet"
               formControlName="bet"
-              class="w-full px-3 py-2 bg-deep-blue-light text-white rounded focus:outline-none focus:ring-2 focus:ring-emerald disabled:opacity-50"
+              class="w-full px-3 py-2 bg-deep-blue-light text-white rounded focus:outline-none focus:ring-2 focus:ring-emerald"
               [min]="1"
               [max]="balance"
               step="0.01"
-              [disabled]="gameInProgress || isActionInProgress"
-              [placeholder]="balance | currency: 'EUR'"
             />
             @if (betForm.get('bet')?.errors?.['required'] && betForm.get('bet')?.touched) {
               <span class="text-xs text-accent-red">Bitte geben Sie einen Einsatz ein</span>
@@ -105,14 +101,7 @@ import { BettingService } from '@blackjack/services/betting.service';
   changeDetection: ChangeDetectionStrategy.OnPush,
 })
 export class GameInfoComponent implements OnChanges {
-  @Input() set balance(value: number) {
+  @Input() balance = 0;
-    this._balance.set(value);
-  }
-  get balance() {
-    return this._balance();
-  }
-  private _balance = signal(0);
-
   @Input() currentBet = 0;
   @Input() gameInProgress = false;
   @Input() isActionInProgress = false;
@@ -120,19 +109,24 @@ export class GameInfoComponent implements OnChanges {
 
   betForm: FormGroup;
 
-  constructor(private bettingService: BettingService) {
+  constructor(private fb: FormBuilder) {
-    this.betForm = this.bettingService.createBetForm();
+    this.betForm = this.fb.group({
+      bet: ['', [Validators.required, Validators.min(1)]],
+    });
   }
 
   ngOnChanges(changes: SimpleChanges): void {
     if (changes['balance']) {
-      this.bettingService.updateBetFormValidators(this.betForm, this.balance);
+      this.betForm
+        .get('bet')
+        ?.setValidators([Validators.required, Validators.min(1), Validators.max(this.balance)]);
+      this.betForm.get('bet')?.updateValueAndValidity();
     }
   }
 
   setBetAmount(percentage: number) {
-    const betAmount = this.bettingService.calculateBetAmount(this.balance, percentage);
+    const betAmount = Math.floor(this.balance * percentage * 100) / 100;
-    if (this.bettingService.isValidBet(betAmount, this.balance)) {
+    if (betAmount >= 1) {
       this.betForm.patchValue({ bet: betAmount });
     }
   }
@@ -140,7 +134,7 @@ export class GameInfoComponent implements OnChanges {
   onSubmit() {
     if (this.betForm.valid) {
       const betAmount = parseFloat(this.betForm.value.bet);
-      if (this.bettingService.isValidBet(betAmount, this.balance)) {
+      if (betAmount <= this.balance) {
         this.newGame.emit(betAmount);
         this.betForm.reset();
       }

frontend/src/app/feature/game/blackjack/services/betting.service.ts

@@ -1,31 +0,0 @@
-import { Injectable } from '@angular/core';
-import { FormBuilder, FormGroup, Validators } from '@angular/forms';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class BettingService {
-  constructor(private fb: FormBuilder) {}
-
-  createBetForm(): FormGroup {
-    return this.fb.group({
-      bet: ['', [Validators.required, Validators.min(1)]],
-    });
-  }
-
-  updateBetFormValidators(form: FormGroup, balance: number): void {
-    form.reset();
-    form
-      .get('bet')
-      ?.setValidators([Validators.required, Validators.min(1), Validators.max(balance)]);
-    form.get('bet')?.updateValueAndValidity();
-  }
-
-  calculateBetAmount(balance: number, percentage: number): number {
-    return Math.floor(balance * percentage * 100) / 100;
-  }
-
-  isValidBet(betAmount: number, balance: number): boolean {
-    return betAmount >= 1 && betAmount <= balance;
-  }
-}