프로젝트 코드 분석

Spring Web Game Project Code Review

Controller

package com.service.indianfrog.domain.game.controller;

import com.service.indianfrog.domain.game.dto.GameBetting;
import com.service.indianfrog.domain.game.dto.GameDto.StartRoundResponse;
import com.service.indianfrog.domain.game.dto.GameInfo;
import com.service.indianfrog.domain.game.dto.GameStatus;
import com.service.indianfrog.domain.game.dto.UserChoices;
import com.service.indianfrog.domain.game.entity.Card;
import com.service.indianfrog.domain.game.entity.GameState;
import com.service.indianfrog.domain.game.service.*;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.messaging.handler.annotation.DestinationVariable;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.messaging.simp.SimpMessageSendingOperations;
import org.springframework.stereotype.Controller;

import java.security.Principal;

@Tag(name = "게임 실행 컨트롤러", description = "인디언 포커 게임 실행 및 종료 컨트롤러입니다.")
@Slf4j
@Controller
public class GameController {

    private final SimpMessageSendingOperations messagingTemplate;
    private final StartGameService startGameService;
    private final GamePlayService gamePlayService;
    private final EndGameService endGameService;
    private final GameSessionService gameSessionService;
    private final ReadyService readyService;
    public GameController(SimpMessageSendingOperations messagingTemplate,
                          StartGameService startGameService, GamePlayService gamePlayService,
                          EndGameService endGameService, GameSessionService gameSessionService, ReadyService readyService) {
        this.messagingTemplate = messagingTemplate;
        this.startGameService = startGameService;
        this.gamePlayService = gamePlayService;
        this.endGameService = endGameService;
        this.gameSessionService = gameSessionService;
        this.readyService = readyService;
    }

    @MessageMapping("/gameRoom/{gameRoomId}/{gameState}")
    public void handleGameState(@DestinationVariable Long gameRoomId, @DestinationVariable String gameState,
                                @Payload(required = false) GameBetting gameBetting, @Payload(required = false) UserChoices userChoices) {

        switch (gameState) {
            case "START" -> {
                StartRoundResponse response = startGameService.startRound(gameRoomId);
                sendUserGameMessage(response); // 유저별 메시지 전송
            }
            case "ACTION", "END", "GAME_END", "USER_CHOICE"-> {
                Object response = switch (gameState) {
                    case "ACTION" ->
                            gamePlayService.playerAction(gameRoomId, gameBetting.getNickname(), gameBetting.getAction());
                    case "END" -> endGameService.endRound(gameRoomId);
                    case "GAME_END" -> endGameService.endGame(gameRoomId);
                    case "USER_CHOICE" -> gameSessionService.processUserChoices(gameRoomId, userChoices);
                    default -> throw new IllegalStateException("Unexpected value: " + gameState);
                };
                // 공통 메시지 전송
                String destination = "/topic/gameRoom/" + gameRoomId;
                messagingTemplate.convertAndSend(destination, response);
            }
            default -> throw new IllegalStateException("Invalid game state: " + gameState);
        }
    }

    // /pub 사용 게임 준비
    @MessageMapping("/gameRoom/{gameRoomId}/ready")
    public void gameReady(
            @DestinationVariable Long gameRoomId, Principal principal) {
        log.info("게임 준비 - 게임방 아이디 : {}", gameRoomId);
        GameStatus gameStatus = readyService.gameReady(gameRoomId, principal);
        String destination = "/topic/gameRoom/" + gameRoomId;
        messagingTemplate.convertAndSend(destination, gameStatus);
    }

    private void sendUserGameMessage(StartRoundResponse response) {
        /* 각 Player 에게 상대 카드 정보와 턴 정보를 전송*/
        String playerOneId = response.getPlayerOneInfo().getId();
        Card playerTwoCard = response.getPlayerTwoInfo().getCard();
        messagingTemplate.convertAndSendToUser(
                playerOneId,
                "/queue/gameInfo",
                new GameInfo(playerTwoCard, response.getTurn())
        );

        String playerTwoId = response.getPlayerTwoInfo().getId();
        Card playerOneCard = response.getPlayerOneInfo().getCard();
        messagingTemplate.convertAndSendToUser(
                playerTwoId,
                "/queue/gameInfo",
                new GameInfo(playerOneCard, response.getTurn())
        );
    }
}

 

웹소켓 기반의 게임 컨트롤러 클래스, GameController 클래스는 인디언 포커 게임의 실행과 종료를 처리하고, 각 메서드는 특정 게임 상태에 따라 다른 액션을 수행한다.

클래스 구성 요소

• 필드 선언: GameController는 여러 서비스 컴포넌트와 SimpMessageSendingOperations를 필드로 가지고 있어서, 게임 로직 처리 및 메시지 전송을 담당합니다.
• 생성자: 이 클래스는 의존성 주입을 사용하여 필요한 서비스들을 초기화합니다.
• 메시지 처리 메소드:
  
  • @MessageMapping 어노테이션이 사용되어 웹소켓을 통한 메시지 매핑을 구현합니다.
  • handleGameState: 게임 상태(gameState)에 따라 다른 액션을 수행합니다. 각 게임 상태는 START, ACTION, END, GAME_END, USER_CHOICE 등으로 구분됩니다.
  • gameReady: 특정 게임 방(gameRoomId)에 대해 게임 준비 상태를 처리합니다.
• 메시지 전송 메소드:
  
  • sendUserGameMessage: 게임 시작 시 플레이어에게 상대방 카드 정보와 턴 정보를 전송합니다.

코드 작동 방식

1. 게임 상태 관리: handleGameState 메소드는 게임의 상태를 관리하고 해당 상태에 맞는 서비스 메소드를 호출합니다.
   • 예를 들어, 게임 시작(START) 상태에서는 startGameService.startRound를 호출합니다.
2. 서비스 호출: 각 상태에 따라 서비스 계층의 메소드를 호출하여 게임 로직을 수행합니다.
3. 메시지 전송: 게임 상태 업데이트 후, messagingTemplate을 사용하여 클라이언트에게 적절한 메시지를 전송합니다. 게임 준비 상태에서는 gameReady 메소드가 게임 상태 정보를 클라이언트에 전송합니다.
4. 유저별 메시지 전송: sendUserGameMessage는 게임이 시작될 때 플레이어별로 상대방 카드 정보와 턴 정보를 전송합니다.

기술적 세부사항

• WebSocket: 웹소켓 통신은 양방향 통신을 가능하게 해주어 실시간으로 데이터 교환을 할 수 있습니다.
• Spring Messaging: @MessageMapping과 SimpMessageSendingOperations를 사용하여 메시지 기반 통신을 구현합니다.
• 의존성 주입: 스프링의 의존성 주입을 통해 각종 서비스 컴포넌트를 GameController에 주입합니다.

개선점

1. 예외 처리

• handleGameState 메소드에서 default 케이스에서 IllegalStateException을 던지는 것은 적절한 예외 처리 방식입니다. 그러나, 예외 메시지를 보다 상세하게 제공하여 어떤 gameState가 유효하지 않은지 명확히 하는 것이 좋습니다.
• 예외 처리를 좀 더 세련되게 처리하기 위해, 커스텀 예외를 정의하고, 적절한 오류 메시지와 HTTP 상태 코드를 반환할 수 있도록 하는 것을 고려해 볼 수 있습니다.

2. 메서드 분리

• handleGameState 메소드는 여러 기능을 수행하고 있습니다. 각 상태에 따른 처리 로직을 별도의 메소드로 분리하여 가독성과 유지보수성을 향상시킬 수 있습니다.
• 예를 들어, processStart, processAction, processEnd, 등과 같은 메소드를 만들어 각 게임 상태를 처리할 수 있습니다.

3. 로깅

• log.info를 사용하여 게임 준비 상태의 로깅을 하고 있는데, 에러 핸들링이나 중요한 비즈니스 로직 처리에서도 로깅을 하는 것이 좋습니다.
• 로그 메시지에는 충분한 컨텍스트 정보를 포함하여 문제 해결 시 유용한 정보를 제공할 수 있도록 합니다.

4. 코드 스타일 및 가독성

• 코드 스타일은 일관성이 중요합니다. 예를 들어, 람다식을 사용하는 경우 일관된 스타일을 유지해야 합니다.
• 가독성을 위해 복잡한 조건문이나 스위치 케이스문은 간단하게 표현하거나 메소드로 추출할 수 있습니다.

5. 자원 관리

• 현재 코드에서는 명시적으로 자원을 관리하는 부분이 보이지 않습니다. 예를 들어, 네트워크 연결, 스트림 등을 사용한다면 적절한 자원 해제가 필요할 수 있습니다.

DTO

GameDto

package com.service.indianfrog.domain.game.dto;

import com.service.indianfrog.domain.game.entity.Card;
import com.service.indianfrog.domain.game.entity.Turn;
import com.service.indianfrog.domain.user.entity.User;
import lombok.Getter;

@Getter
public class GameDto {

    @Getter
    public static class StartRoundResponse {
        private String gameState;
        private int round;
        private PlayerInfo playerOneInfo;
        private PlayerInfo playerTwoInfo;
        private Turn turn;

        public StartRoundResponse(String gameState, int round, User playerOne, User playerTwo,
                                  Card playerOneCard, Card playerTwoCard, Turn turn) {
            this.gameState = gameState;
            this.round = round;
            this.playerOneInfo = new PlayerInfo(playerOne, playerOneCard);
            this.playerTwoInfo = new PlayerInfo(playerTwo, playerTwoCard);
            this.turn = turn;
        }
    }

    @Getter
    public static class EndRoundResponse {
        private String gameState;
        private int round;
        private Long roundWinnerId;
        private Long roundLoserId;
        private int roundPot;

        public EndRoundResponse(String gameState, int round, Long roundWinnerId, Long roundLoserId, int roundPot) {
            this.gameState = gameState;
            this.round = round;
            this.roundWinnerId = roundWinnerId;
            this.roundLoserId = roundLoserId;
            this.roundPot = roundPot;
        }
    }

    @Getter
    public static class EndGameResponse {
        private String gameState;
        private Long gameWinnerId;
        private Long gameLoserId;
        private int winnerPot;
        private int loserPot;

        public EndGameResponse(String gameState, Long gameWinner, Long gameLoser, int winnerPot, int loserPot) {
            this.gameState = gameState;
            this.gameWinnerId = gameWinner;
            this.gameLoserId = gameLoser;
            this.winnerPot = winnerPot;
            this.loserPot = loserPot;
        }
    }
}

 

인디언 포커 게임의 DTO(Data Transfer Object)를 정의한 것입니다. GameDto 클래스 내에는 여러 정적 내부 클래스들이 정의되어 있으며, 이 클래스들은 게임의 다양한 상태에 대한 응답을 표현합니다.

 

1. StartRoundResponse

• 게임의 라운드 시작 시 필요한 정보를 담고 있습니다.
• gameState, round, playerOneInfo, playerTwoInfo, turn 필드를 포함하여, 현재 게임 상태, 라운드 번호, 플레이어 정보 및 턴 정보를 관리합니다.
• PlayerInfo는 플레이어의 정보와 해당 플레이어가 가진 카드를 담는 내부 클래스로 사용됩니다.

2. EndRoundResponse

• 라운드가 끝났을 때의 상태 정보를 담습니다.
• gameState, round, roundWinnerId, roundLoserId, roundPot 필드를 통해 해당 라운드의 게임 상태, 라운드 번호, 승자 및 패자의 ID, 그리고 라운드 포트(배팅 금액)를 관리합니다.

3. EndGameResponse

• 게임이 종료됐을 때의 상태 정보를 담습니다.
• gameState, gameWinnerId, gameLoserId, winnerPot, loserPot 필드를 통해 게임의 최종 상태, 승자 및 패자의 ID, 승자와 패자의 포트를 관리합니다.

코드 리뷰

• 이해하기 쉬운 구조: GameDto는 게임의 다양한 단계를 대표하는 응답 객체를 명확하게 구분하여 정의하고 있습니다. 이는 코드의 가독성과 유지보수성을 높여줍니다.
• @Getter 사용: Lombok 라이브러리의 @Getter 어노테이션을 사용하여 getter 메소드를 자동으로 생성합니다. 이는 코드의 간결성을 높여줍니다.
• 가시성과 캡슐화: DTO의 필드는 private로 선언되어 있어 캡슐화를 잘 지키고 있습니다. 이는 데이터의 무결성을 보장합니다.

개선 사항

• Validation: 필드에 대한 입력 검증 로직이 포함되어 있지 않습니다. 예를 들어, null 값이나 부적절한 값이 전달되는 것을 방지하기 위해 생성자 또는 setter에서 입력값 검증을 고려할 수 있습니다.
• 문서화: 각 필드와 클래스의 용도를 설명하는 자바독(Javadoc) 주석을 추가하면 코드의 이해도를 높일 수 있습니다.

 

GameBetting

package com.service.indianfrog.domain.game.dto;

import lombok.Getter;

@Getter
public class GameBetting {
    private String action;
    private String nickname;
}

 

GameBetting이라는 DTO(Data Transfer Object) 클래스를 정의하고 있습니다. 이 클래스는 게임 내에서 발생하는 배팅에 대한 정보를 담고 있습니다.

클래스 구조

• action: 플레이어가 게임에서 취한 행동을 나타내는 문자열 필드입니다. 예를 들어 'raise', 'call', 'fold'와 같은 배팅 관련 액션을 나타낼 수 있습니다.
• nickname: 플레이어의 닉네임을 나타내는 문자열 필드입니다. 이는 게임 내에서 플레이어를 식별하는 데 사용됩니다.

코드 리뷰

• Getter 메소드: Lombok 라이브러리의 @Getter 어노테이션을 사용하여, 필드에 대한 getter 메소드를 자동으로 생성하고 있습니다. 이는 코드의 반복을 줄여주고 가독성을 높여줍니다.
• 캡슐화: 필드가 private로 선언되어 있어 클래스 외부에서 직접적인 접근을 방지합니다. 이는 객체의 상태를 보호하고 데이터의 무결성을 유지하는 데 도움을 줍니다.

개선 사항

• 데이터 검증: 생성자나 세터에서 입력 데이터의 유효성을 검증하는 로직이 필요할 수 있습니다. 예를 들어, nickname이 null이거나 빈 문자열이 아닌지 확인하거나, action이 허용되는 범위 내의 값인지 확인하는 것이 좋습니다.
• 문서화: 각 필드와 클래스의 목적을 설명하는 자바독(Javadoc) 주석을 추가하면 다른 개발자가 코드를 이해하는 데 도움이 됩니다.

전반적으로, 이 클래스는 간결하고 목적에 맞게 잘 구성되어 있습니다. 데이터 검증 및 문서화를 통해 더욱 견고하고 이해하기 쉬운 코드로 만들 수 있습니다.

 

GameInfo

package com.service.indianfrog.domain.game.dto;

import com.service.indianfrog.domain.game.entity.Card;
import com.service.indianfrog.domain.game.entity.Turn;
import lombok.Getter;

@Getter
public class GameInfo {
    private Card playerCard;
    private Turn turn;

    public GameInfo(Card playerCard, Turn turn) {
        this.playerCard = playerCard;
        this.turn = turn;
    }
}

 

GameInfo라는 DTO(Data Transfer Object) 클래스를 정의하고 있습니다. 이 클래스는 게임의 진행 상황을 나타내는 데 사용되며, 특히 플레이어에게 보여줄 카드 정보와 턴 정보를 포함합니다.

클래스 구조

• playerCard: Card 타입으로, 게임 내에서 플레이어에게 할당된 카드를 나타냅니다.
• turn: Turn 타입으로, 게임의 현재 턴 상태를 나타냅니다.

코드 리뷰

• Getter 메소드: Lombok 라이브러리의 @Getter 어노테이션을 사용하여, 클래스 필드에 대한 getter 메소드를 자동으로 생성합니다. 이는 코드 중복을 줄이고 가독성을 높여줍니다.
• 캡슐화: 필드가 private로 선언되어 있어 클래스 외부에서 필드에 직접 접근하는 것을 방지합니다. 이는 객체의 상태 보호와 데이터 무결성 유지에 도움이 됩니다.

개선 사항

• 데이터 검증: 생성자에서 입력 데이터의 유효성을 검증하는 로직을 추가할 수 있습니다. 예를 들어, playerCard나 turn이 null이 아님을 보장하는 검증이 필요할 수 있습니다.
• 문서화: 클래스와 필드 목적을 설명하는 자바독(Javadoc) 주석을 추가하여 다른 개발자가 코드를 더 쉽게 이해할 수 있도록 할 수 있습니다.

코드는 명확하고 잘 구조화되어 있으며, 목적에 맞게 작성되었습니다. 적절한 데이터 검증과 문서화를 통해 코드의 품질을 더욱 향상시킬 수 있을 것입니다.

 

GameResult

package com.service.indianfrog.domain.game.dto;

import com.service.indianfrog.domain.user.entity.User;
import lombok.Getter;

@Getter
public class GameResult {

    private Long winnerId;
    private Long loserId;
    private int winnerPot;
    private int loserPot;

    public GameResult(User winner, User loser) {
        this.winnerId = winner.getId();
        this.loserId = loser.getId();
    }

    public GameResult(User winner, User loser, int winnerPot, int loserPot) {
        this.winnerId = winner.getId();
        this.loserId = loser.getId();
        this.winnerPot = winnerPot;
        this.loserPot = loserPot;
    }
}

 

이 코드는 GameResult라는 DTO(Data Transfer Object) 클래스를 정의하고 있으며, 게임의 결과, 즉 승자와 패자의 정보 및 배팅된 포트에 대한 정보를 담고 있습니다.

클래스 구조

• winnerId와 loserId: 게임의 승자와 패자를 나타내는 User 엔티티의 ID입니다. 승자와 패자의 식별자를 저장합니다.
• winnerPot와 loserPot: 승자와 패자가 게임에서 획득하거나 잃은 포인트(포트)의 양입니다.

코드 리뷰

장점

• 캡슐화: 필드들이 private로 선언되어 외부에서 직접 접근할 수 없습니다. 이는 객체의 상태를 보호하고 데이터의 무결성을 유지하는 데 도움을 줍니다.
• Getter 메소드의 자동 생성: Lombok 라이브러리의 @Getter 어노테이션을 사용하여 필드의 getter 메소드를 자동으로 생성하고 있습니다. 이는 코드의 반복을 줄여주고 유지 관리를 간소화합니다.

개선 사항

• 데이터 검증: 생성자에서 입력 데이터의 유효성을 검증하는 로직을 추가할 수 있습니다. 예를 들어, winner와 loser가 null이 아닌지 확인하는 검증이 필요할 수 있습니다. 또한 winnerPot와 loserPot 값이 음수가 아닌지 확인할 필요가 있습니다.
• 문서화: 클래스와 각 메소드에 대한 자바독(Javadoc) 주석을 추가하여, 다른 개발자들이 코드의 목적을 더 쉽게 이해할 수 있도록 하는 것이 좋습니다.
• 생성자 오버로드: 두 개의 생성자가 있는데, 첫 번째 생성자는 포트 정보를 설정하지 않습니다. 이 경우, winnerPot와  loserPot가 기본값인 0으로 설정될 것입니다. 이는 의도치 않은 결과를 초래할 수 있으므로, 명확히 의도를 드러내거나 해당 필드를 설정할 수 있는 메커니즘을 제공하는 것이 좋습니다.

전반적으로, GameResult 클래스는 명확하게 게임의 결과를 표현하는 데 필요한 정보를 잘 정의하고 있습니다. 적절한 데이터 검증과 문서화를 통해 코드의 품질을 더욱 향상시킬 수 있을 것입니다.

 

GameStatus

package com.service.indianfrog.domain.game.dto;

import com.service.indianfrog.domain.game.entity.GameState;
import lombok.Getter;

@Getter
public class GameStatus {
    private Long gameRoomId;
    private String nickname;
    private GameState gameState;

    public GameStatus(Long gameRoomId, String nickname, GameState gameState) {
        this.gameRoomId = gameRoomId;
        this.nickname = nickname;
        this.gameState = gameState;
    }
}

 

GameStatus 클래스는 인디언 포커 게임의 게임 세션 현황을 전달하기 위해 설계된 DTO(Data Transfer Object, 데이터 전송 객체)입니다. 이 클래스는 게임 방의 ID, 플레이어의 닉네임, 그리고 게임의 현재 상태를 담고 있습니다.

클래스 구조

• gameRoomId: Long 타입으로, 특정 게임 방을 식별합니다. 다양한 게임 세션을 구분하는 데 필요한 정보입니다.
• nickname: String 타입으로, 현재 게임 상태와 관련된 플레이어의 닉네임을 나타냅니다. 이는 게임 방 내에서 어떤 플레이어의 상태인지 식별하는 데 도움을 줍니다.
• gameState: GameState 인스턴스로, 게임의 가능한 상태들(시작 중, 진행 중, 일시 정지, 종료 등)을 나열하는 열거형이나 클래스일 것입니다.

코드 리뷰

장점

• 캡슐화: 필드들이 private로 선언되어 있어 객체의 상태가 외부에서 직접적으로 조작되는 것을 방지합니다. 이는 데이터의 무결성을 유지하는 데 중요합니다.
• 간결함과 명확성: 생성자는 제공된 인자들로 필드를 직접 초기화합니다. Lombok의 @Getter 어노테이션을 사용하여 모든 필드에 대한 getter 메소드를 자동으로 생성하므로, 코드 중복을 줄이고 가독성을 높입니다.
• 불변성 측면: setter 메소드를 제공하지 않고 필드를 private final로 선언함으로써 (여기서는 final이 사용되지 않았지만, 추천하는 바입니다), 객체의 상태가 생성 후 변경되지 않도록 하여 데이터 전송 객체로서의 불변성을 유지하는 것이 좋습니다.

개선 사항

• 데이터 검증: 생성자에서 입력값의 유효성을 검증하는 로직이 없습니다(예를 들어, gameRoomId나 nickname이 null이 아닌지 확인). 유효성 검증을 구현함으로써 유효하지 않은 GameStatus 인스턴스의 생성을 방지하고 데이터 무결성을 처음부터 강화할 수 있습니다.
• 문서화: 클래스와 각 필드의 목적을 설명하는 자바독(Javadoc) 주석을 추가하면, 팀 설정에서 또는 API가 공개적으로 사용될 때 다른 개발자들이 코드를 더 쉽게 이해할 수 있습니다.
• final 수정자: 불변성을 강화하기 위해 필드를 final로 선언할 수 있습니다. 이렇게 하면 필드가 한 번만 할당되도록 보장되고, DTO의 무결성이 그 수명 주기 동안 유지됩니다.

결론

전반적으로 GameStatus 클래스는 잘 구성되어 있으며 DTO로서의 목적을 효과적으로 수행합니다. 제안된 개선 사항을 구현하면 그 견고성과 유지보수성이 향상되어 더욱 신뢰성 있고 사용하기 쉬운 클래스가 될 것입니다. 이러한 개선은 특히 다중 스레드 환경이나 클래스 인스턴스가 애플리케이션의 다양한 부분이나 네트워크를 통해 공유될 때 중요합니다.

 

PlayerInfo

package com.service.indianfrog.domain.game.dto;

import com.service.indianfrog.domain.game.entity.Card;
import com.service.indianfrog.domain.user.entity.User;
import lombok.Getter;

@Getter
public class PlayerInfo {
    private String id;
    private Card card;

    public PlayerInfo(User player, Card card) {
        this.id = player.getId().toString();
        this.card = card;
    }
}

 

PlayerInfo 클래스는 게임 플레이어의 기본 정보를 나타내는 DTO(Data Transfer Object, 데이터 전송 객체)입니다. 이 클래스는 플레이어의 ID와 해당 플레이어가 소유한 카드 정보를 담고 있습니다. 

 

클래스 구조

• id: String 타입으로, 게임 플레이어의 고유 식별자입니다. 이 ID는 User 엔티티의 ID를 문자열로 변환하여 저장합니다.
• card: Card 타입으로, 플레이어가 소유한 카드를 나타냅니다. 이 카드는 게임에서 플레이어의 현재 카드 상태를 반영합니다.

코드 리뷰

장점

• 간결성: 클래스는 간결하며, 명확하게 두 가지 필수 정보를 관리합니다. 이는 클래스의 목적을 명확히 하고, 사용하기 쉽게 만듭니다.
• 캡슐화: 모든 필드는 private로 선언되어 외부에서 직접 접근할 수 없습니다. 이는 객체의 상태를 외부의 영향으로부터 보호합니다.
• 데이터 무결성: 생성자를 통해 객체가 생성될 때 필요한 모든 정보를 초기화하므로, 객체가 일관된 상태를 유지합니다. 또한, Lombok의 @Getter 어노테이션을 사용하여 필드의 getter 메소드를 자동 생성하므로, 필드 값은 안전하게 접근될 수 있습니다.

개선 사항

• 데이터 검증: 현재 생성자에서는 User나 Card 객체가 null인지 확인하지 않습니다. 이는 잠재적으로 NullPointerException을 발생시킬 수 있습니다. 안전한 객체 생성을 위해 입력 값에 대한 유효성 검사를 추가하는 것이 좋습니다.
• 문서화: 클래스와 메소드에 대한 자바독(Javadoc) 주석을 추가하여 클래스의 사용 목적과 메소드의 역할을 명확히 할 수 있습니다. 특히, 공개 API로 사용될 경우 이는 매우 중요합니다.
• 유연성 증가: 현재 id 필드는 User의 ID를 문자열로 변환하여 사용합니다. 만약 User의 ID가 필드 타입 변경 등의 이유로 다른 형태로 사용되어야 한다면, 이를 더 유연하게 처리할 수 있는 설계를 고려할 수 있습니다.

결론

PlayerInfo 클래스는 게임 플레이어의 ID와 카드 정보를 효과적으로 담고 있어 게임 로직 처리에 필수적인 정보를 제공합니다. 제안된 개선 사항을 통해 클래스의 견고성과 사용성을 더욱 향상시킬 수 있습니다.

 

UserChoices

package com.service.indianfrog.domain.game.dto;

import com.service.indianfrog.domain.game.entity.UserChoice;
import lombok.Getter;

@Getter
public class UserChoices {
    private String nickname;
    private UserChoice userChoice;


    public UserChoices(String nickname, UserChoice userChoice) {

        this.nickname = nickname;
        this.userChoice = userChoice;
    }
}

 

UserChoices 클래스는 플레이어의 선택을 나타내는 DTO(Data Transfer Object)로 사용됩니다. 이 클래스는 플레이어의 닉네임과 해당 플레이어가 선택한 옵션을 포함하고 있습니다. 이 정보는 게임 로직에서 중요한 역할을 하며, 플레이어의 결정을 서버나 다른 클라이언트와 공유할 때 사용됩니다.

클래스 구조

• nickname: String 타입으로, 플레이어의 닉네임을 저장합니다. 이는 게임 내에서 플레이어를 식별하는 데 사용됩니다.
• userChoice: UserChoice 타입으로, 플레이어가 게임 내에서 선택한 옵션을 나타냅니다. UserChoice는 다양한 선택을 모델링하는 별도의 클래스나 열거형일 수 있습니다.

코드 리뷰

장점

• 캡슐화: 모든 필드는 private로 선언되어 있어, 객체의 상태가 외부에서 직접 변경될 수 없습니다. 이는 객체의 무결성을 보장합니다.
• Lombok 라이브러리 사용: @Getter 어노테이션을 통해 각 필드에 대한 getter 메소드가 자동으로 생성됩니다. 이는 코드의 간결성을 높이고, 필드에 안전하게 접근할 수 있도록 합니다.

개선 사항

• 데이터 검증: 생성자에서 nickname과 userChoice가 null이 아닌지 확인하는 로직이 없습니다. 잘못된 값이 입력되면, 런타임에 NullPointerException과 같은 오류가 발생할 수 있습니다. 안전한 객체 생성을 위해 입력 값에 대한 유효성 검사를 추가하는 것이 좋습니다.
• 문서화: 각 필드와 클래스의 목적을 설명하는 자바독(Javadoc) 주석을 추가하여, 코드의 목적과 사용 방법을 명확히 할 수 있습니다. 이는 특히 API가 외부에 공개될 때 매우 중요합니다.
• 확장성 고려: 현재 userChoice 필드는 UserChoice 타입을 사용하고 있습니다. 이 타입이 어떻게 정의되어 있는지에 따라, 향후 확장성과 유연성을 고려한 설계가 중요할 수 있습니다. 예를 들어, 선택지가 다양해질 경우 이를 어떻게 효율적으로 처리할지 고민할 필요가 있습니다.

결론

UserChoices 클래스는 게임의 로직 처리에 필수적인 사용자의 선택을 효과적으로 나타내며, 코드의 명확성과 간결성이 잘 유지되고 있습니다. 제안된 개선 사항을 통해 클래스의 견고성을 더욱 향상시키고, 사용자 입력의 오류 가능성을 줄일 수 있습니다. 이러한 개선을 통해 시스템의 안정성과 신뢰성을 높일 수 있을 것입니다.

 

Entity(Model)

Betting

package com.service.indianfrog.domain.game.entity;

import lombok.Getter;

@Getter
public enum Betting {
    /* 배팅 상태 Enum Class
    * CHECK : 상대와 같은 판돈 걸기
    * RAISE : 판돈의 2배 걸기
    * DIE : 라운드 포기하기 */
    CHECK("CHECK"),
    RAISE("RAISE"),
    DIE("DIE")
    ;

    private final String betting;
    Betting(String betting) {
        this.betting = betting;
    }
}

 

Betting 클래스는 인디언 포커 게임에서 사용되는 배팅 상태를 나타내는 열거형(enum)입니다. 각 상태는 플레이어가 게임에서 선택할 수 있는 다양한 배팅 옵션을 정의합니다.

클래스 구조

• CHECK: "상대와 같은 판돈 걸기"라는 의미로, 플레이어가 현재 포트와 동일한 금액을 배팅하겠다는 선택을 나타냅니다.
• RAISE: "판돈의 2배 걸기"라는 의미로, 플레이어가 현재 배팅 금액의 두 배를 걸겠다는 선택을 나타냅니다.
• DIE: "라운드 포기하기"라는 의미로, 플레이어가 해당 라운드에서 더 이상 참여하지 않겠다는 선택을 나타냅니다.

각 상태는 문자열로 된 betting 값을 가지며, 이 값은 배팅 상태를 더 명확하게 설명하는 데 사용됩니다.

코드 리뷰

장점

• 명확성과 간결성: 열거형을 사용하여 각 배팅 상태를 명확하고 간결하게 표현하고 있습니다. 이는 코드의 가독성을 높이고, 오류 가능성을 줄입니다.
• 데이터 무결성: final 키워드를 사용하여 betting 필드가 변경되지 않도록 함으로써, 각 인스턴스의 불변성을 보장합니다.
• Lombok 라이브러리 사용: @Getter 어노테이션을 통해 각 상태의 betting 값에 대한 getter 메소드를 자동으로 생성하고 있습니다. 이는 추가적인 getter 구현을 줄여줍니다.

개선 사항

• 문서화: 각 상태에 대한 자세한 설명이 주석으로만 제공되고 있습니다. 이 정보를 자바독(Javadoc) 형식으로 변경하여 API 문서에서도 이 정보가 표시되도록 하는 것이 좋습니다.
• 활용성 증대: 현재 betting 필드는 각 상태를 문자열로 저장하고 있으나, 실제 게임 로직에서 이 값을 어떻게 활용할지에 대한 구체적인 구현이나 예시가 없습니다.
  • 예를 들어, 각 배팅 상태에 따라 실제 게임에서의 포인트 계산 방법을 메소드로 추가할 수 있습니다.\

결론

Betting 열거형은 인디언 포커 게임의 배팅 로직을 효과적으로 모델링하는 좋은 예입니다. 이 열거형은 게임의 규칙을 명확하게 정의하며, 각 배팅 상태를 코드에서 쉽게 참조할 수 있게 합니다. 개선 사항을 통해 문서화를 강화하고 게임 로직과의 연동을 개선한다면, 이 클래스는 더욱 유용하게 활용될 수 있습니다.

 

Card

package com.service.indianfrog.domain.game.entity;

import lombok.Getter;

@Getter
public enum Card {
    DECK1_CARD1(1, 1),
    DECK1_CARD2(1, 2),
    DECK1_CARD3(1, 3),
    DECK1_CARD4(1, 4),
    DECK1_CARD5(1, 5),
    DECK1_CARD6(1, 6),
    DECK1_CARD7(1, 7),
    DECK1_CARD8(1, 8),
    DECK1_CARD9(1, 9),
    DECK1_CARD10(1, 10),
    DECK2_CARD1(2, 1),
    DECK2_CARD2(2, 2),
    DECK2_CARD3(2, 3),
    DECK2_CARD4(2, 4),
    DECK2_CARD5(2, 5),
    DECK2_CARD6(2, 6),
    DECK2_CARD7(2, 7),
    DECK2_CARD8(2, 8),
    DECK2_CARD9(2, 9),
    DECK2_CARD10(2, 10)
    ;

    private final int number;
    private final int deckNumber;

    Card(int number, int deckNumber) {
        this.number = number;
        this.deckNumber = deckNumber;
    }
}

 

Card 열거형은 포커 게임과 같은 애플리케이션에서 카드 덱을 구조화하는 방법을 보여줍니다. 각 카드는 덱과 그 덱 내의 숫자로 고유하게 식별됩니다.

클래스 구조

• 필드:
  • number: 덱 내의 숫자를 나타냅니다(예: 1부터 10까지).
  • deckNumber: 카드가 속한 덱을 나타냅니다. 이는 게임에서 여러 덱을 다루기 위한 것입니다.

코드 리뷰

장점

• 명확성 및 구체성: 열거형 값은 각 카드를 덱과 숫자로 명확하게 정의하여 게임 로직 내에서 카드를 쉽게 식별하고 관리할 수 있게 합니다.
• 캡슐화 및 불변성: private final 필드 사용은 카드가 생성된 후 그 속성(number와 deckNumber)이 변경되지 않도록 보장합니다. 이는 객체의 임의적 또는 악의적 수정을 방지하는 자바의 좋은 실습입니다.
• Lombok의 @Getter 어노테이션: 두 필드(number와 deckNumber)에 대한 getter 메소드를 자동으로 생성하여 코드를 간소화하고 가독성을 높입니다.

개선 사항

• 확장성: 현재 두 덱 각각에 10개의 카드가 있는 설정은 소규모 애플리케이션에 적합할 수 있지만, 더 많은 덱이나 다른 구성이 필요한 게임에는 잘 맞지 않을 수 있습니다. 다양한 유형의 덱과 카드 수를 처리할 수 있는 보다 동적인 카드 생성 방법을 고려하는 것이 좋습니다.
• 문서화: 열거형과 그 생성자에 자바독 주석을 추가하는 것이 좋습니다. 이는 향후 이 코드를 작업할 다른 개발자들에게 각 코드 부분이 무엇을 하고, 카드가 어떻게 구조화되어 있는지 명확하게 설명할 수 있습니다.
• 유틸리티 메소드: 게임 로직이 어떻게 구성되어 있는지에 따라, Card 열거형에 추가적인 메소드를 추가하는 것이 도움이 될 수 있습니다. 예를 들어, 두 카드를 비교하는 메소드, 해당하는 경우 카드의 모양을 확인하는 메소드 또는 기타 게임 특정 기능을 개선하는 메소드 등이 유용할 수 있습니다.

결론

Card 열거형은 게임에서 카드를 간단하고 명확하게 나타내는 데 효과적입니다. 구조화된 접근 방식은 게임의 로직을 관리하고 디버깅하기 쉽게 만듭니다. 그러나 확장성과 추가 기능에 대한 고려는 이 구현을 더 다양한 카드 게임 유형이나 더 복잡한 게임 규칙에 적합하게 만들 수 있습니다. 더 포괄적인 문서화와 유틸리티 메소드를 추가하면 이 코드를 사용하고 확장하고 유지하기가 더 쉬워질 것입니다.

 

GameState

package com.service.indianfrog.domain.game.entity;

import lombok.Getter;

@Getter
public enum GameState {
    /* 게임 상태 Enum Class
    * ENTER : 게임방 입장
    * READY : 게임 준비
    * ALL_READY : 모두 게임 준비
    * START : 게임 시작
    * ACTION : 유저 행동
    * BET : 배팅
    * END : 라운드 종료
    * LEAVE : 게임 방 떠나기
    * GAME_END : 게임 종료
    * USER_CHOICE : 유저 선택(게임 재시작, 게임 나가기)*/
    ENTER("ENTER"),
    READY("READY"),
    UNREADY("UNREADY"),
    NO_ONE_READY("NO_ONE_READY"),
    ALL_READY("ALL_READY"),
    START("START"),
    ACTION("ACTION"),
    END("END"),
    BET("BET"),
    LEAVE("LEAVE"),
    GAME_END("GAME_END"),
    USER_CHOICE("USER_CHOICE")
    ;

    private final String gameState;
    GameState(String gameState) {
        this.gameState = gameState;
    }
}

 

GameState 열거형은 인디언 포커 게임의 다양한 상태를 나타내는 데 사용됩니다. 이 클래스는 게임의 라이프사이클을 관리하고, 게임의 현재 상태를 명확하게 식별하는 데 중요한 역할을 합니다. 각 상태는 특정 게임 이벤트나 행동과 연결됩니다. 

클래스 구조

• 필드:
  
  • gameState: 게임의 현재 상태를 문자열로 나타내는 필드입니다.

게임 상태 설명

• ENTER: 게임방 입장
• READY: 게임 준비 상태
• UNREADY: 준비가 취소된 상태
• NO_ONE_READY: 아무도 준비하지 않은 상태
• ALL_READY: 모든 플레이어가 준비 완료 상태
• START: 게임 시작
• ACTION: 플레이어의 행동(예: 카드 선택, 배팅 조정 등)
• BET: 배팅 상태
• END: 라운드 종료
• LEAVE: 게임방에서 나가기
• GAME_END: 게임 종료
• USER_CHOICE: 플레이어의 선택 상태(게임 재시작, 게임 나가기 등)

코드 리뷰

장점

• 명확성: 각 게임 상태가 열거형 값으로 명확하게 정의되어 있어, 게임 로직 내에서 상태를 쉽게 참조하고 비교할 수 있습니다. 이는 코드의 가독성과 유지보수성을 높입니다.
• 데이터 무결성과 불변성: final 필드를 사용하여 각 상태값이 생성 후 변경되지 않도록 보장합니다. 이는 불변 객체의 좋은 예시입니다.
• Lombok의 @Getter 어노테이션: 상태값에 대한 getter 메소드를 자동으로 생성하여 코드의 중복을 줄이고, 데이터 접근을 표준화합니다.

개선 사항

• 문서화: 각 상태에 대해 자바독 주석을 추가하여, API 문서화를 강화하고 다른 개발자들이 각 상태의 사용 목적을 더 쉽게 이해할 수 있도록 하는 것이 좋습니다.
• 확장성과 유연성: 게임의 요구사항이 변경될 때 쉽게 적용할 수 있도록, 상태 관리 방식을 유연하게 구성하는 것을 고려할 수 있습니다. 예를 들어, 상태 전이를 관리하는 로직을 도입하여 게임 상태의 변경을 더 동적으로 처리할 수 있습니다.

결론

GameState 열거형은 게임의 상태를 효과적으로 모델링하며, 게임의 진행을 명확하게 추적할 수 있는 강력한 도구입니다. 코드의 명확성과 간결성이 잘 유지되고 있으며, 약간의 문서화와 상태 관리 방식의 개선을 통해 더욱 강력하고 유용하게 활용될 수 있습니다.

 

UserChoice

package com.service.indianfrog.domain.game.entity;

public enum UserChoice {

    READY("READY"),
    PLAY_AGAIN("PLAY_AGAIN"), // 게임을 다시 하기로 선택
    LEAVE("LEAVE") // 게임방에서 나가기로 선택
    ;

    private final String userChoice;
    UserChoice(String userChoice) {
        this.userChoice = userChoice;
    }
}

 

UserChoice 열거형은 플레이어가 게임 내에서 할 수 있는 몇 가지 주요 선택을 정의합니다. 이 클래스는 플레이어의 상호작용을 명확하게 나타내며, 게임 로직에서 플레이어의 의사결정을 처리하는 데 사용됩니다.

클래스 구조

• userChoice: 플레이어의 선택을 문자열로 저장합니다. 이 값은 플레이어의 각 선택을 구별하는 데 사용됩니다.

선택 옵션 설명

• READY: 플레이어가 게임 준비가 완료되었음을 나타냅니다.
• PLAY_AGAIN: 플레이어가 게임을 다시 시작하길 원함을 나타냅니다. 이 선택은 게임이 끝난 후 다시 시작할 때 사용됩니다.
• LEAVE: 플레이어가 게임방에서 나가기를 선택했음을 나타냅니다. 이 선택은 보통 게임 종료 후나 불만족스러운 게임 경험에서 발생할 수 있습니다.

코드 리뷰

장점

• 명확성: UserChoice 열거형은 플레이어가 할 수 있는 선택을 간단하고 명확하게 정의합니다. 이는 게임 로직에서 이러한 선택을 쉽게 참조하고 처리할 수 있도록 합니다.
• 데이터 무결성과 불변성: private final 필드를 사용하여 생성된 후에 선택 값이 변경되지 않도록 합니다. 이는 객체의 안정성과 예측 가능성을 높여줍니다.

개선 사항

• 문서화: 각 선택에 대해 자바독 주석을 추가하여, 이 선택들이 게임 내에서 어떻게 작동하는지 설명하는 것이 좋습니다. 이는 API 문서화를 통해 다른 개발자가 코드를 이해하는 데 도움이 될 수 있습니다.
• 확장성 고려: 만약 게임의 요구사항이 변경되어 더 많은 사용자 선택이 필요한 경우, 이 열거형을 쉽게 확장할 수 있는 구조를 고려하는 것이 중요합니다. 예를 들어, 사용자의 선택에 따라 특정 액션을 트리거하는 전략 패턴을 도입할 수 있습니다.

결론

UserChoice 열거형은 게임에서 플레이어의 선택을 효과적으로 모델링합니다. 이는 게임 로직에서 중요한 의사결정을 처리하며, 각 선택이 게임의 흐름에 어떻게 영향을 미치는지 명확하게 나타냅니다. 추가적인 문서화와 조금 더 유연한 설계를 고려한다면, 이 클래스는 더욱 강력하고 유용하게 활용될 수 있습니다.

 

Game

package com.service.indianfrog.domain.game.entity;

import com.service.indianfrog.domain.user.entity.User;
import jakarta.persistence.*;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;

import java.util.HashSet;
import java.util.Set;

@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
public class Game {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ElementCollection(fetch = FetchType.LAZY)
    @Enumerated(EnumType.STRING) // Enum 타입을 저장
    private Set<Card> usedCards = new HashSet<>();

    @ManyToOne(fetch = FetchType.EAGER)
    private User playerOne;

    @ManyToOne(fetch = FetchType.EAGER)
    private User playerTwo;

    @Enumerated(EnumType.STRING) // 카드 Enum을 저장
    private Card playerOneCard;

    @Enumerated(EnumType.STRING) // 카드 Enum을 저장
    private Card playerTwoCard;

    private int betAmount;

    private int pot; // 현재 라운드의 포트
    private int nextRoundPot; // 다음 라운드로 이월할 포트

    @ManyToOne(fetch = FetchType.EAGER)
    private User foldedUser;

    // 플레이어가 라운드에서 획득한 포인트
    private int playerOneRoundPoints;
    private int playerTwoRoundPoints;

    // 라운드 정보
    private int round;

    // Constructor and methods
    public Game(User playerOne, User playerTwo) {
        this.playerOne = playerOne;
        this.playerTwo = playerTwo;
        this.usedCards = new HashSet<>();
    }

    public void addUsedCard(Card card) {
        this.usedCards.add(card);
    }

    public void incrementRound() {
        this.round++;
    }

    public void setPlayerOneCard(Card card) {
        this.playerOneCard = card;
    }

    public void setPlayerTwoCard(Card card) {
        this.playerTwoCard = card;
    }

    public void setBetAmount(int betAmount) {
        this.betAmount = betAmount;
    }

    // 게임 팟을 가져옵니다.
    public int getPot() {
        return pot;
    }

    // 게임 팟을 설정합니다.
    public void setPot(int pot) {
        this.pot = pot;
    }

    // 게임에서 포기한 유저를 설정합니다.
    public void setFoldedUser(User user) {
        this.foldedUser = user;
    }

    public void addPlayerOneRoundPoints(int points) {
        this.playerOneRoundPoints += points;
    }

    public void addPlayerTwoRoundPoints(int points) {
        this.playerTwoRoundPoints += points;
    }

    public void setNextRoundPot(int pot) {
        // 다음 라운드로 이월할 포트 금액을 설정합니다.
        this.nextRoundPot += pot; // 이월될 금액을 누적합니다.
    }

    public void resetRound() {
        /* 라운드 정보 초기화
        * 베팅액, 각 플레이어 카드 정보 초기화*/
        this.pot = 0;
        this.playerOneCard = null;
        this.playerTwoCard = null;
    }

    // 게임과 관련된 상태를 초기화하는 메서드
    public void resetGame() {
        /* 게임에 사용된 카드 정보,
        * 게임에서 각 유저가 획득한 포인트,
        * 라운드 정보 초기화*/
        usedCards.clear();
        playerOneRoundPoints = 0;
        playerTwoRoundPoints = 0;
        round = 0;
    }
}

 

Game 클래스는 인디언 포커 게임의 게임 세션을 나타내며, JPA 엔티티로서 데이터베이스에 게임의 상태를 저장하기 위해 사용됩니다. 이 클래스는 게임 참여자, 사용된 카드, 베팅 금액, 그리고 게임의 진행 상황 등을 관리합니다.

클래스 구조 및 필드 설명

• id: 게임의 고유 식별자입니다. 자동으로 생성되는 값입니다.
• usedCards: 게임에서 사용된 카드들의 집합입니다. 카드는 EnumType.STRING으로 저장됩니다.
• playerOne, playerTwo: 게임에 참여하는 두 플레이어를 나타냅니다. ManyToOne 관계는 이 플레이어들이 여러 게임에 참여할 수 있음을 의미합니다.
• playerOneCard, playerTwoCard: 각 플레이어가 소지한 카드입니다.
• betAmount: 한 라운드에서의 베팅 금액입니다.
• pot: 현재 라운드의 총 포트 금액입니다.
• nextRoundPot: 다음 라운드로 이월할 포트 금액입니다.
• foldedUser: 포기한 유저를 나타냅니다.
• playerOneRoundPoints, playerTwoRoundPoints: 각 플레이어가 라운드에서 획득한 포인트입니다.
• round: 현재 게임의 라운드 번호입니다.

코드 리뷰

장점

• 데이터 모델의 완성도: 모든 주요 게임 요소가 잘 표현되어 있어 게임의 상태를 종합적으로 관리할 수 있습니다.
• @NoArgsConstructor(access = AccessLevel.PROTECTED): 기본 생성자의 접근 수준을 protected로 설정하여 불필요한 객체 생성을 방지하고, JPA 프록시 생성과 같은 기술적 요구사항을 충족합니다.
• 메소드로 상태 관리: set, add, reset과 같은 메소드를 통해 객체의 상태를 변경할 수 있으며, 이는 객체지향 원칙을 잘 따르고 있습니다.

개선 사항

• 캐스케이딩과 생명주기 관리: @ManyToOne 관계에 캐스케이딩 옵션이나 영속성 전파 설정을 추가하는 것을 고려할 수 있습니다. 예를 들어, 플레이어가 삭제되었을 때 이를 참조하는 게임도 함께 처리되어야 할 경우 cascade = CascadeType.ALL 등을 설정할 수 있습니다.
• @Enumerated(EnumType.STRING): 이 설정은 카드의 이름을 문자열로 저장합니다. 이는 EnumType.ORDINAL을 사용하는 것보다 타입 안전성 측면에서 더 나은 선택입니다. 그러나, 데이터베이스에 저장될 때 카드의 이름이 변경되면 문제가 발생할 수 있으므로, 이 부분을 고려하여 설계를 진행하는 것이 좋습니다.
• 문서화: 각 필드와 메소드에 대한 자바독 주석을 추가하여, 클래스의 구조와 메소드의 목적을 더 명확하게 할 수 있습니다.

결론

Game 클래스는 게임 세션의 관리에 필요한 다양한 요소를 잘 통합하고 있으며, 객체의 상태를 효과적으로 관리합니다. 클래스 설계는 확장성과 유지보수성을 고려하여 잘 구성되었습니다. 몇 가지 개선 사항을 통해 더욱 견고하고 안정적인 데이터 모델을 구현할 수 있습니다.

 

Turn

package com.service.indianfrog.domain.game.entity;

import com.service.indianfrog.domain.user.entity.User;

import java.util.List;

public class Turn {
    private List<User> players;
    private int currentPlayer;

    public Turn(List<User> players) {
        this.players = players;
        this.currentPlayer = 0;
    }

    public void nextTurn() {
        currentPlayer = (currentPlayer + 1) % players.size();
    }

    public User getCurrentPlayer() {
        return players.get(currentPlayer);
    }
}

 

Turn 클래스는 게임에서 턴을 관리하는 역할을 담당합니다. 이 클래스는 참여하는 플레이어의 목록과 현재 플레이어의 인덱스를 관리하면서, 게임 내에서 누가 행동할 차례인지를 결정합니다. 이를 통해 턴 기반 게임의 로직을 구현할 수 있습니다.

클래스 구조 및 기능

• players: 게임에 참여하는 플레이어들의 리스트입니다. 이 리스트는 게임에 참여하는 모든 사용자를 포함합니다.
• currentPlayer: 현재 턴을 진행하고 있는 플레이어의 리스트 내 인덱스를 저장합니다. 이 인덱스는 턴이 진행됨에 따라 업데이트됩니다.

메소드 설명

• Turn(List<User> players): 생성자는 플레이어 리스트를 받아 객체를 초기화하며, currentPlayer를 0으로 설정하여 게임의 시작 플레이어를 첫 번째 플레이어로 지정합니다.
• nextTurn(): 이 메소드는 현재 플레이어의 인덱스를 다음 플레이어로 이동시킵니다. 리스트의 끝에 도달하면 다시 리스트의 시작으로 순환합니다. 이는 (currentPlayer + 1) % players.size()를 통해 구현됩니다.
• getCurrentPlayer(): 현재 턴을 진행 중인 플레이어 객체를 반환합니다. 이 메소드는 게임 로직에서 현재 플레이어의 행동을 처리할 때 사용됩니다.

코드 리뷰

장점

• 순환 턴 로직: nextTurn 메소드의 구현은 간결하면서도 효과적으로 턴이 순환하는 로직을 처리합니다. 이는 게임이 무한 루프 없이 계속 진행될 수 있게 해줍니다.
• 객체 지향적 접근: 플레이어 리스트와 현재 플레이어 인덱스를 캡슐화하여, 턴 관리 로직이 명확하고 조작이 간편합니다.

개선 사항

• 예외 처리: 현재 getCurrentPlayer 메소드는 players.size()가 0일 때 IndexOutOfBoundsException을 발생시킬 수 있습니다. 플레이어 리스트가 비어 있을 경우를 처리하는 로직을 추가하는 것이 좋습니다.
• 확장성 고려: 만약 게임에 더 복잡한 턴 규칙이 추가된다면, Turn 클래스를 인터페이스나 추상 클래스로 확장하여 다양한 턴 로직을 적용할 수 있게 하는 디자인을 고려할 수 있습니다.
• 문서화: 각 메소드와 필드에 자바독 주석을 추가하여, 클래스의 사용 방법과 각 컴포넌트의 역할을 명확히 하는 것이 좋습니다.

결론

Turn 클래스는 턴 기반 게임의 핵심적인 부분을 효율적으로 처리합니다. 클래스는 간결하고 명확한 로직을 제공하며, 게임의 턴 순서를 관리하는 데 필요한 기본적인 기능을 잘 수행합니다. 몇 가지 예외 처리와 확장성을 고려한다면 더욱 견고하고 유용한 구성 요소가 될 수 있습니다.

 

Utils

GameValidator

package com.service.indianfrog.domain.game.utils;

import com.service.indianfrog.domain.game.entity.Game;
import com.service.indianfrog.domain.gameroom.entity.GameRoom;
import com.service.indianfrog.domain.gameroom.entity.ValidateRoom;
import com.service.indianfrog.domain.user.entity.User;
import com.service.indianfrog.global.exception.ErrorCode;
import com.service.indianfrog.global.exception.RestApiException;
import jakarta.persistence.EntityNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class GameValidator {
    /* 생성자를 통한 필드 주입 */
    private final RepositoryHolder repositoryHolder;

    public GameValidator(RepositoryHolder repositoryHolder) {
        this.repositoryHolder = repositoryHolder;
    }

    public GameRoom validateAndRetrieveGameRoom(Long gameRoomId) {
        return repositoryHolder.gameRoomRepository.findById(gameRoomId)
                .orElseThrow(() -> new EntityNotFoundException("존재하지 않는 게임방 입니다."));
    }

    @Transactional
    public Game initializeOrRetrieveGame(GameRoom gameRoom) {
        Game game = gameRoom.getCurrentGame();
        String host = repositoryHolder.validateRoomRepository.findByHostTrue().getParticipants();
        String participant = repositoryHolder.validateRoomRepository.findByHostFalse().getParticipants();

        User playerOne = repositoryHolder.userRepository.findByEmail(host).orElseThrow(() -> new RestApiException(ErrorCode.NOT_FOUND_GAME_USER.getMessage()));
        User playerTwo = repositoryHolder.userRepository.findByEmail(participant).orElseThrow(() -> new RestApiException(ErrorCode.NOT_FOUND_GAME_USER.getMessage()));

        if (game == null) {
            gameRoom.startNewGame(playerOne, playerTwo);
            repositoryHolder.gameRoomRepository.save(gameRoom);
            game = gameRoom.getCurrentGame();
        }
        return game;
    }

    /* 게임 룸 정보 업데이트 로직 팀원과 의논을 통해 수정 필요*/
    @Transactional
    public void saveGameRoomState(GameRoom gameRoom) {
        repositoryHolder.gameRoomRepository.save(gameRoom);
    }

    public User findUserByNickname(String nickname) {
        return repositoryHolder.userRepository.findByNickname(nickname);
//                .orElseThrow(() -> new EntityNotFoundException("존재하지 않는 유저입니다."));
    }
}

 

GameValidator 클래스는 게임방과 게임에 관련된 유효성 검사와 상태 초기화를 처리하는 스프링 서비스입니다. 이 클래스는 주로 게임방의 유효성을 확인하고, 새 게임을 초기화하며, 사용자 정보를 검색하는 등의 기능을 수행합니다.

클래스 구조 및 기능 설명

• 필드 주입:
  • RepositoryHolder: 다양한 리포지토리에 접근하기 위한 컨테이너 역할을 하는 객체. 게임방, 사용자 등의 데이터에 접근하는데 사용됩니다.
• 메소드 설명:
  • validateAndRetrieveGameRoom(Long gameRoomId): 주어진 게임방 ID에 해당하는 게임방을 찾고, 없으면 EntityNotFoundException 예외를 던집니다.
  • initializeOrRetrieveGame(GameRoom gameRoom): 주어진 게임방에서 현재 진행 중인 게임을 찾거나 새 게임을 시작합니다. 게임방의 호스트와 참여자 정보를 사용하여 플레이어를 식별하고, 새 게임을 생성합니다.
  • saveGameRoomState(GameRoom gameRoom): 게임방의 상태를 데이터베이스에 저장합니다.
  • findUserByNickname(String nickname): 닉네임을 통해 사용자를 찾습니다. 사용자가 없는 경우 주석 처리된 예외 발생 코드가 포함되어 있습니다.

코드 리뷰

장점

• 명확한 역할 분리: GameValidator 클래스는 게임방 및 게임 관련 유효성 검사와 상태 관리를 효과적으로 수행합니다. 각 메소드는 명확하고 구체적인 역할을 가지고 있어, 유지보수가 용이합니다.
• 예외 처리: 유효하지 않은 게임방 ID에 대해 적절한 예외 처리를 하고 있으며, 이는 서비스의 안정성을 높입니다.
• 트랜잭션 관리: @Transactional 어노테이션을 사용하여 데이터베이스 작업의 일관성을 보장하고 있습니다.

개선 사항

• 주석 처리된 예외 처리: findUserByNickname 메소드에서 예외 처리가 주석 처리되어 있습니다. 사용자가 존재하지 않는 경우 예외를 던지거나 다른 처리를 하는 것이 좋습니다. 이를 통해 상위 로직에서 적절한 조치를 취할 수 있습니다.
• 코드의 의존성: initializeOrRetrieveGame 메소드에서 findByHostTrue() 및 findByHostFalse() 메소드를 사용하는 방식  이 구체적인 비즈니스 로직에 매우 의존적입니다. 이러한 구현은 유지보수성을 저하시킬 수 있으며, 더 유연하고 확장 가능한 설계를 고려할 필요가 있습니다.
• 리포지토리 접근 방식 개선: RepositoryHolder 클래스를 통한 리포지토리 접근은 유용할 수 있지만, 각 리포지토리에 대한 직접적인 의존성 주입을 고려하는 것이 더 표준적인 스프링 관례에 부합할 수 있습니다.

결론

GameValidator 클래스는 게임방과 게임 상태의 유효성 검사 및 관리를 위한 중요한 서비스를 제공합니다. 코드는 전반적으로 잘 구성되어 있으나, 예외 처리와 의존성 관리 방식에 대한 개선을 통해 더욱 견고하고 유지보수가 용이한 서비스가 될 수 있습니다.

 

RepositoryHolder

package com.service.indianfrog.domain.game.utils;

import com.service.indianfrog.domain.gameroom.repository.GameRoomRepository;
import com.service.indianfrog.domain.gameroom.repository.ValidateRoomRepository;
import com.service.indianfrog.domain.user.repository.UserRepository;
import org.springframework.stereotype.Component;

@Component
public class RepositoryHolder {
    public final GameRoomRepository gameRoomRepository;
    public final UserRepository userRepository;
    public final ValidateRoomRepository validateRoomRepository;

    public RepositoryHolder(GameRoomRepository gameRoomRepository, UserRepository userRepository, ValidateRoomRepository validateRoomRepository) {
        this.gameRoomRepository = gameRoomRepository;
        this.userRepository = userRepository;
        this.validateRoomRepository = validateRoomRepository;
    }
}

 

RepositoryHolder 클래스는 여러 종류의 리포지토리 인스턴스를 포함하고 있으며, 게임 시스템 내에서 필요한 리포지토리에 대한 중앙 집중식 접근 지점을 제공합니다. 이 패턴은 리포지토리 의존성을 하나의 쉽게 주입 가능한 컴포넌트로 통합함으로써 의존성 관리를 단순화할 수 있습니다.

클래스 구조

• 필드:
  
  • gameRoomRepository: 게임방 데이터에 접근하고 관리하는 데 사용되는 GameRoomRepository 인스턴스입니다.
  • userRepository: 사용자 데이터에 접근하고 관리하는 데 사용되는 UserRepository 인스턴스입니다.
  • validateRoomRepository: 방 조건이나 규칙을 검증하는 데 사용될 것으로 보이는 ValidateRoomRepository 인스턴스입니다.

생성자

• 생성자는 세 개의 파라미터를 받으며, 각 파라미터는 특정 리포지토리 유형에 해당합니다. 이 구성은 RepositoryHolder 인스턴스가 생성될 때 필요한 모든 리포지토리가 제공되도록 보장합니다.

사용 및 이점

• 중앙 집중화: 단일 클래스를 통해 리포지토리 접근을 중앙 집중화함으로써, 애플리케이션 전반에 걸쳐 리포지토리 의존성 관리를 단순화합니다. 이는 리포지토리 접근이 필요한 여러 서비스나 컴포넌트에 특히 유용합니다.
• 설정 단순화: 리포지토리 의존성을 한 곳에서 관리함으로써, 특히 복잡한 의존성 그래프를 가진 프로젝트에서 설정과 관리를 용이하게 합니다.
• 응집성 향상: 관련 의존성을 하나의 홀더 클래스에 그룹화함으로써 코드베이스의 응집성을 향상시키고, 조직화 및 관리가 용이하게 됩니다.

코드 리뷰

장점

• 깔끔한 아키텍처: 리포지토리 인젝션을 위한 홀더 클래스 사용은 서비스 클래스를 더 깔끔하고 비즈니스 로직에 집중할 수 있도록 합니다.
• 테스트 용이성: RepositoryHolder 사용으로 단위 테스트에서 의존성을 모킹하기 쉬워지며, 각 테스트 클래스에서 개별 리포지토리를 모킹할 필요가 없습니다.

개선 사항

• 유연성 문제: RepositoryHolder가 리포지토리 접근을 중앙 집중화하긴 하지만, 유연성을 저하시킬 수 있습니다. 서비스가 하나의 리포지토리만 필요한 경우에도 RepositoryHolder에 의존해야 하므로, 간단한 사용 사례에는 과할 수 있습니다.
• 의존성 투명성: 홀더 클래스 사용은 클래스의 실제 의존성을 덜 명확하게 만들 수 있습니다. 컴포넌트가 실제로 어떤 리포지토리를 사용하는지 파악하기 위해서는 구현 세부 사항을 살펴봐야 할 수 있습니다.

모범 사례 및 대안

• 선택적 인젝션: 모든 리포지토리를 위한 홀더 대신 필요한 컴포넌트에 리포지토리를 직접 인젝션하는 것을 고려하세요. 이 접근 방식은 의존성 관리의 명확성과 투명성을 유지하며, 최소 권한 원칙을 따릅니다.
• 문서화: RepositoryHolder 내 각 리포지토리의 목적과 사용법을 잘 문서화하여 혼동이나 오용을 방지하세요. 이는 특히 여러 개발자가 이 컴포넌트를 사용할 수 있는 팀 환경에서 중요합니다.
• 프로파일 또는 구성 기반 인젝션: 시스템이 복잡하고 다양한 구성이 필요한 경우, 스프링의 프로파일이나 조건부 구성을 사용하여 동적으로 리포지토리 의존성을 관리하는 것을 고려하세요.

결론

RepositoryHolder 클래스는 스프링 기반 애플리케이션에서 리포지토리 의존성을 관리하는 깔끔한 솔루션을 제공합니다. 그러나 시스템의 유연성과 의존성 투명성에 미치는 영향을 신중하게 고려할 필요가 있습니다. 애플리케이션의 특정 요구 사항과 규모에 따라, 직접 리포지토리 인젝션을 사용하는 것이 때로는 더 선호될 수 있습니다.

Service

StartGameService

package com.service.indianfrog.domain.game.service;

import com.service.indianfrog.domain.game.dto.GameDto.StartRoundResponse;
import com.service.indianfrog.domain.game.entity.Card;
import com.service.indianfrog.domain.game.entity.Game;
import com.service.indianfrog.domain.game.entity.Turn;
import com.service.indianfrog.domain.game.utils.GameValidator;
import com.service.indianfrog.domain.gameroom.entity.GameRoom;
import com.service.indianfrog.domain.user.entity.User;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Tag(name = "라운드 시작 서비스", description = "게임(라운드) 시작 서비스 로직")
@Slf4j(topic = "게임 시작 서비스 레이어")
@Service
public class StartGameService {

    /* 생성자를 통한 필드 주입 */
    private final GameValidator gameValidator;
    private final GameTurnService gameTurnService;

    public StartGameService(GameValidator gameValidator, GameTurnService gameTurnService) {
        this.gameValidator = gameValidator;
        this.gameTurnService = gameTurnService;
    }

    @Transactional
    public StartRoundResponse startRound(Long gameRoomId) {
        GameRoom gameRoom = gameValidator.validateAndRetrieveGameRoom(gameRoomId);
        Game game = gameValidator.initializeOrRetrieveGame(gameRoom);

        performRoundStart(game);
        gameValidator.saveGameRoomState(gameRoom);
        int round = game.getRound();
        Turn turn = gameTurnService.getTurn(game.getId());

        return new StartRoundResponse("ACTION", round, game.getPlayerOne(), game.getPlayerTwo(),
                game.getPlayerOneCard(), game.getPlayerTwoCard(), turn);
    }

    private void performRoundStart(Game game) {
        /* 라운드 수 저장, 라운드 베팅 금액 설정, 플레이어에게 카드 지급, 플레이어 턴 설정*/
        game.incrementRound();

        int betAmount = calculateInitialBet(game.getPlayerOne(), game.getPlayerTwo());
        game.setBetAmount(betAmount);

        List<Card> availableCards = prepareAvailableCards(game);
        assignRandomCardsToPlayers(game, availableCards);

        if (game.getRound() == 1) {
            initializeTurnForGame(game);
        }
    }

    private int calculateInitialBet(User playerOne, User playerTwo) {
        int playerOnePoints = playerOne.getPoints();
        int playerTwoPoints = playerTwo.getPoints();
        int min = Math.min(playerOnePoints, playerTwoPoints);
        if (min < 2000) {
            return min;
        }
        return 2000; // 10%의 포인트를 초기 베팅 금액으로 설정
    }

    private List<Card> prepareAvailableCards(Game game) {
        /* 사용한 카드 목록과 전체 카드 목록을 가져옴
        * 전체 카드 목록에서 사용한 카드 목록을 제외하고 남은 카드 목록을 반환한다*/
        Set<Card> usedCards = game.getUsedCards();
        Set<Card> allCards = EnumSet.allOf(Card.class); // 성능 개선 여지 있음
        allCards.removeAll(usedCards);
        return new ArrayList<>(allCards);
    }

    private void assignRandomCardsToPlayers(Game game, List<Card> availableCards) {
        /* 카드를 섞은 후 플레이어에게 각각 한장 씩 제공
        * 플레이어에게 제공한 카드는 사용한 카드목록에 포함되어 다음 라운드에서는 사용되지 않는다*/
        Collections.shuffle(availableCards);

        Card playerOneCard = availableCards.get(0);
        Card playerTwoCard = availableCards.get(1);

        game.setPlayerOneCard(playerOneCard);
        game.setPlayerTwoCard(playerTwoCard);

        game.addUsedCard(playerOneCard);
        game.addUsedCard(playerTwoCard);
    }

    private void initializeTurnForGame(Game game) {
        List<User> players = new ArrayList<>();
        players.add(game.getPlayerOne());
        players.add(game.getPlayerTwo());

        Turn turn = new Turn(players);
        gameTurnService.setTurn(game.getId(), turn);
    }
}

 

StartGameService 클래스는 인디언 포커 게임의 라운드를 시작하는 주요 로직을 담당하는 서비스 컴포넌트입니다. 이 서비스는 게임방의 유효성 검증, 게임 상태 초기화, 카드 배분, 베팅 금액 설정 등의 작업을 처리합니다.

클래스 구조 및 메소드 설명

• 필드 주입:
  
  • GameValidator: 게임방과 게임의 유효성을 검사하고 초기화하는 역할을 합니다.
  • GameTurnService: 게임의 턴 관리를 담당하는 서비스입니다.
• 메소드 설명:
  
  • startRound(Long gameRoomId): 주어진 게임방 ID를 기반으로 게임방을 검증하고, 게임을 초기화한 후, 라운드를 시작합니다. 플레이어에게 카드를 배분하고, 베팅 금액을 설정합니다. 이 메소드에서는 StartRoundResponse DTO를 반환하여 게임의 현재 상태를 전달합니다.
  • performRoundStart(Game game): 실제 게임 상태를 업데이트하고, 라운드를 시작하는 로직을 수행합니다. 베팅 금액을 계산하고, 사용 가능한 카드를 준비한 후, 플레이어에게 카드를 할당합니다.
  • calculateInitialBet(User playerOne, User playerTwo): 초기 베팅 금액을 계산합니다. 플레이어의 포인트를 기반으로 최소 베팅 금액을 결정합니다.
  • prepareAvailableCards(Game game): 게임에서 아직 사용되지 않은 카드 목록을 준비합니다. 사용한 카드를 제외하고 남은 카드들을 반환합니다.
  • assignRandomCardsToPlayers(Game game, List<Card> availableCards): 사용 가능한 카드 목록에서 무작위로 카드를 선택하여 플레이어에게 할당합니다.
  • initializeTurnForGame(Game game): 게임의 턴을 초기화합니다. 게임에 참여하는 플레이어 목록을 생성하고 턴을 설정합니다.

코드 리뷰

장점

• 모듈화와 책임 분리: StartGameService는 게임 시작에 필요한 여러 단계를 잘 분리하여 각각의 기능을 모듈화하고 있습니다. 이는 코드의 가독성과 유지보수성을 높여줍니다.
• 트랜잭션 관리: @Transactional 어노테이션을 사용하여 데이터베이스 작업을 관리하며, 이는 데이터 일관성을 보장합니다.

개선 사항

• 에러 처리와 로깅: 메소드 실행 도중 발생할 수 있는 예외 상황에 대한 처리가 명시적으로 보이지 않습니다. 에러 처리 로직을 추가하고, 필요한 곳에 로깅을 추가하여 오류 발생 시 추적이 용이하도록 할 필요가 있습니다.
• 성능 최적화: prepareAvailableCards 메소드에서 전체 카드 세트를 매번 생성하는 것은 성능에 영향을 줄 수 있습니다. 더 효율적인 카드 관리 방식을 고려할 필요가 있습니다.

결론

StartGameService는 게임 라운드 시작을 위한 핵심 로직을 효과적으로 처리하고 있으며, 게임방의 상태를 초기화하고 게임을 진행하는 데 필요한 여러 작업을 적절히 수행합니다. 몇 가지 예외 처리와 성능 최적화를 통해 서비스의 안정성과 효율성을 더욱 향상시킬 수 있을 것입니다.

 

GamePlayService

package com.service.indianfrog.domain.game.service;

import com.service.indianfrog.domain.game.entity.Betting;
import com.service.indianfrog.domain.game.entity.Game;
import com.service.indianfrog.domain.game.entity.GameState;
import com.service.indianfrog.domain.game.entity.Turn;
import com.service.indianfrog.domain.game.utils.GameValidator;
import com.service.indianfrog.domain.gameroom.entity.GameRoom;
import com.service.indianfrog.domain.user.entity.User;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

@Tag(name = "게임 플레이 서비스", description = "게임 플레이 서비스 로직")
@Slf4j
@Service
public class GamePlayService {

    private final GameValidator gameValidator;
    private final GameTurnService gameTurnService;

    public GamePlayService(GameValidator gameValidator, GameTurnService gameTurnService) {
        this.gameValidator = gameValidator;
        this.gameTurnService = gameTurnService;
    }

    @Transactional
    public GameState playerAction(Long gameRoomId, String nickname, String action) {
        GameRoom gameRoom = gameValidator.validateAndRetrieveGameRoom(gameRoomId);
        Game game = gameValidator.initializeOrRetrieveGame(gameRoom);
        User user = gameValidator.findUserByNickname(nickname);
        Turn turn = gameTurnService.getTurn(game.getId());

        /* 유저의 턴이 맞는지 확인*/
        if (!turn.getCurrentPlayer().equals(user)) {
            throw new IllegalStateException("당신의 턴이 아닙니다, 선턴 유저의 행동이 끝날 때까지 기다려 주세요.");
        }

        Betting betting = Betting.valueOf(action.toUpperCase());
        return switch (betting) {
            case CHECK -> performCheckAction(game, user, turn);
            case RAISE -> performRaiseAction(game, user, turn);
            case DIE -> performDieAction(game, user);
        };
    }

    private GameState performCheckAction(Game game, User user, Turn turn) {
        /* 유저 턴 확인*/
        boolean isFirstTurn = turn.getCurrentPlayer().equals(user);

        if (!isFirstTurn) {
            int userPoints = user.getPoints();
            int currentBet = game.getBetAmount();
            if (userPoints >= currentBet) {
                user.setPoints(userPoints - currentBet);
                game.setPot(game.getPot() + currentBet);
            } else {
                game.setPot(game.getPot() + userPoints);
                user.setPoints(0);
            }
            return GameState.END;
        }

        /* 선턴 유저 CHECK*/
        user.setPoints(user.getPoints() - game.getBetAmount());
        game.setPot(game.getPot() + game.getBetAmount());
        turn.nextTurn();
        return GameState.ACTION;
    }

    private GameState performRaiseAction(Game game, User user, Turn turn) {
        int userPoints = user.getPoints();

        if (userPoints <= 0) {
            return GameState.END;
        }
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int raiseAmount=0;

        /* RAISE 베팅 액 설정*/
        try {
            System.out.print("베팅할 금액을 입력하세요: ");
            String input = br.readLine();
            raiseAmount = Integer.parseInt(input);
        } catch (IOException e) {
            log.error("입력 오류가 발생했습니다.");
            raiseAmount = Math.min(raiseAmount, userPoints);
            e.printStackTrace();
        }


        user.setPoints(userPoints - raiseAmount);
        game.setPot(game.getPot() + raiseAmount);
        game.setBetAmount(raiseAmount);

        turn.nextTurn();
        return GameState.ACTION;
    }

    private GameState performDieAction(Game game, User user) {
        User playerOne = game.getPlayerOne();
        User playerTwo = game.getPlayerTwo();
        User winner = user.equals(playerOne) ? playerTwo : playerOne;

        /* DIE 하지 않은 유저에게 Pot 이월*/
        int pot = game.getPot();
        if (winner.equals(playerOne)) {
            game.addPlayerOneRoundPoints(pot);
        } else {
            game.addPlayerTwoRoundPoints(pot);
        }

        game.setFoldedUser(user);

        return GameState.END;
    }

}

 

GamePlayService 클래스는 인디언 포커 게임에서 플레이어의 행동을 처리하는 서비스 로직을 담당하는 클래스입니다. 이 클래스는 게임방 유효성 검증, 게임 상태 초기화, 플레이어 행동 실행 등의 기능을 제공합니다.

클래스의 주요 기능

• 플레이어 행동 처리: 플레이어가 게임에서 수행할 수 있는 다양한 행동(CHECK, RAISE, DIE)을 처리합니다.
• 턴 관리: GameTurnService를 사용하여 현재 게임의 턴 관리를 담당합니다.

주요 메소드 설명

• playerAction(Long gameRoomId, String nickname, String action): 지정된 게임방에서 특정 플레이어의 행동을 처리합니다. 유효성 검사 후, 해당 행동에 맞는 처리를 수행합니다.
• performCheckAction(Game game, User user, Turn turn): 플레이어가 CHECK 행동을 선택했을 때 실행되는 메소드입니다. 플레이어가 베팅 금액만큼 포인트를 사용하고, 게임의 포트를 증가시킵니다.
• performRaiseAction(Game game, User user, Turn turn): 플레이어가 RAISE 행동을 선택했을 때, 베팅 금액을 설정하고 게임의 포트를 업데이트합니다. 사용자 입력을 통해 베팅 금액을 결정합니다.
• performDieAction(Game game, User user): 플레이어가 DIE 행동을 선택했을 때 실행되는 메소드입니다. 포기한 플레이어를 설정하고, 남은 플레이어에게 현재 포트의 점수를 부여합니다.

코드 리뷰

장점

• 철저한 유효성 검사: 게임방과 플레이어의 유효성을 검사하여 오류 가능성을 최소화합니다.
• 상태 관리: @Transactional 어노테이션을 사용하여 데이터베이스 상태의 일관성을 보장합니다.

개선 사항

• 사용자 입력 처리: performRaiseAction 메소드에서 BufferedReader를 사용하여 콘솔에서 사용자 입력을 받습니다. 이 방식은 웹 어플리케이션에서 적절하지 않으며, 사용자 입력은 보통 프론트엔드나 API 통해 처리됩니다.
• 예외 처리: 사용자의 행동을 처리하는 동안 다양한 예외 상황이 발생할 수 있습니다. 예외 처리 로직을 강화하여, 모든 가능한 오류 상황을 처리하고 적절한 피드백을 제공하는 것이 필요합니다.
• 성능 고려: 현재 구현에서는 모든 사용자 입력을 받기 위해 대기하는 방식은 효율적이지 않습니다. 사용자 입력을 비동기적으로 처리하거나 다른 방법을 고려할 필요가 있습니다.

결론

GamePlayService는 게임 내에서 플레이어의 행동을 관리하는 중요한 역할을 수행합니다. 그러나 사용자 입력 처리와 예외 관리에 대한 개선이 필요합니다. 이러한 개선을 통해 서비스의 안정성과 사용자 경험을 높일 수 있습니다.

 

EndGameService

package com.service.indianfrog.domain.game.service;

import com.service.indianfrog.domain.game.dto.GameDto.EndGameResponse;
import com.service.indianfrog.domain.game.dto.GameDto.EndRoundResponse;
import com.service.indianfrog.domain.game.dto.GameResult;
import com.service.indianfrog.domain.game.entity.Card;
import com.service.indianfrog.domain.game.entity.Game;
import com.service.indianfrog.domain.game.entity.Turn;
import com.service.indianfrog.domain.game.utils.GameValidator;
import com.service.indianfrog.domain.game.utils.RepositoryHolder;
import com.service.indianfrog.domain.gameroom.entity.GameRoom;
import com.service.indianfrog.domain.user.entity.User;
import com.service.indianfrog.global.exception.ErrorCode;
import com.service.indianfrog.global.exception.RestApiException;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.persistence.EntityNotFoundException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Tag(name = "게임/라운드 종료 서비스", description = "게임/라운드 종료 서비스 로직")
@Slf4j
@Service
public class EndGameService {

    private final GameValidator gameValidator;
    private final RepositoryHolder repositoryHolder;
    private final GameTurnService gameTurnService;

    public EndGameService(GameValidator gameValidator, RepositoryHolder repositoryHolder, GameTurnService gameTurnService) {
        this.gameValidator = gameValidator;
        this.repositoryHolder = repositoryHolder;
        this.gameTurnService = gameTurnService;
    }

    /* 라운드 종료 로직*/
    @Transactional
    public EndRoundResponse endRound(Long gameRoomId) {
        GameRoom gameRoom = gameValidator.validateAndRetrieveGameRoom(gameRoomId);
        Game game = gameValidator.initializeOrRetrieveGame(gameRoom);

        /* 라운드 승자 패자 결정
        승자에게 라운드 포인트 할당
        라운드 포인트 값 가져오기*/
        GameResult gameResult = determineGameResult(game);
        assignRoundPointsToWinner(game, gameResult);
        int roundPot = game.getPot();

        /* 라운드 승자가 선턴을 가지도록 설정*/
        initializeTurnForGame(game, gameResult.getWinnerId());

        /* 라운드 정보 초기화*/
        game.resetRound();

        /* 게임 상태 결정 : 다음 라운드 시작 상태 반환 or 게임 종료 상태 반환*/
        String gameState = determineGameState(game);

        return new EndRoundResponse(gameState, game.getRound(), gameResult.getWinnerId(), gameResult.getLoserId(), roundPot);
    }

    /* 게임 종료 로직*/
    @Transactional
    public EndGameResponse endGame(Long gameRoomId) {
        GameRoom gameRoom = gameValidator.validateAndRetrieveGameRoom(gameRoomId);
        Game game = gameValidator.initializeOrRetrieveGame(gameRoom);

        /* 게임 결과 처리 및 게임 정보 초기화*/
        GameResult gameResult = processGameResults(game);

        /* 유저 선택 상태 반환*/
        return new EndGameResponse("USER_CHOICE", gameResult.getWinnerId(), gameResult.getLoserId(),
                gameResult.getWinnerPot(), gameResult.getLoserPot());
    }


    /* 검증 메서드 필드*/
    /* 라운드 승자, 패자 선정 메서드 */
    private GameResult determineGameResult(Game game) {
        User playerOne = game.getPlayerOne();
        User playerTwo = game.getPlayerTwo();

        Card playerOneCard = game.getPlayerOneCard();
        Card playerTwoCard = game.getPlayerTwoCard();

        if (playerOneCard.getNumber() != playerTwoCard.getNumber()) {
            return playerOneCard.getNumber() > playerTwoCard.getNumber() ?
                    new GameResult(playerOne, playerTwo) : new GameResult(playerTwo, playerOne);
        }

        /* 카드 숫자가 같으면 1번 덱의 카드를 가진 플레이어가 승리*/
        return playerOneCard.getDeckNumber() == 1 ?
                new GameResult(playerOne, playerTwo) : new GameResult(playerTwo, playerOne);
    }

    /* 라운드 포인트 승자에게 할당하는 메서드*/
    private void assignRoundPointsToWinner(Game game, GameResult gameResult) {
        User winner = repositoryHolder.userRepository.findById(gameResult.getWinnerId())
                .orElseThrow(() -> new RestApiException(ErrorCode.NOT_FOUND_USER.getMessage()));

        int pointsToAdd = game.getPot();

        winner.setPoints(winner.getPoints() + pointsToAdd);

        if (winner.equals(game.getPlayerOne())) {
            game.addPlayerOneRoundPoints(pointsToAdd);
        } else {
            game.addPlayerTwoRoundPoints(pointsToAdd);
        }
    }

    /* 게임 내 라운드가 모두 종료되었는지 확인하는 메서드*/
    private String determineGameState(Game game) {
        /* 한 게임의 라운드는 현재 3라운드 까지임
         * 라운드 정보를 확인해 3 라운드일 경우 게임 종료 상태를 반환
         * 라운드 정보가 3보다 적은 경우 다음 라운드 시작을 위한 상태 반환
         * game.getRound >= 3 비교 과정을 게임 시작 시 유저의 입력 값을 통해
         * maxRound 필드 등을 만들어서 비교하는 등의 개선도 가능*/
        if (game.getRound() >= 3) {
            return "GAME_END";
        }
        return "START";
    }

    /* 게임 결과 처리 메서드*/
    private GameResult processGameResults(Game game) {
        int playerOneTotalPoints = game.getPlayerOneRoundPoints();
        int playerTwoTotalPoints = game.getPlayerTwoRoundPoints();

        /* 게임 승자와 패자를 정하고 각각의 정보 업데이트*/
        User gameWinner = playerOneTotalPoints > playerTwoTotalPoints ? game.getPlayerOne() : game.getPlayerTwo();
        User gameLoser = gameWinner.equals(game.getPlayerOne()) ? game.getPlayerTwo() : game.getPlayerOne();

        gameWinner.incrementWins();
        gameLoser.incrementLosses();

        /* 승자와 패자의 총 획득 포인트*/
        int winnerTotalPoints = gameWinner.equals(game.getPlayerOne()) ? playerOneTotalPoints : playerTwoTotalPoints;
        int loserTotalPoints = gameLoser.equals(game.getPlayerOne()) ? playerOneTotalPoints : playerTwoTotalPoints;

        /* 게임 데이터 초기화*/
        game.resetGame();

        return new GameResult(gameWinner, gameLoser, winnerTotalPoints, loserTotalPoints);
    }

    /* 1라운드 이후 턴 설정 메서드*/
    private void initializeTurnForGame(Game game, Long winnerId) {
        List<User> players = new ArrayList<>();

        /* 전 라운드 승자를 해당 첫 턴으로 설정*/
        User roundWinner = repositoryHolder.userRepository.findById(winnerId)
                        .orElseThrow(() -> new EntityNotFoundException("유저를 찾을 수 없습니다."));
        players.add(roundWinner);

        User player = (!roundWinner.equals(game.getPlayerOne()))
                ? game.getPlayerTwo() : game.getPlayerOne();
        players.add(player);

        gameTurnService.setTurn(game.getId(), new Turn(players));
    }
}

 

EndGameService 클래스는 인디언 포커 게임의 라운드와 게임 종료 로직을 처리하는 서비스입니다. 이 클래스는 게임 라운드의 승자 결정, 포인트 할당, 게임 및 라운드 상태 업데이트 등의 중요한 기능을 수행합니다.

클래스 기능과 메서드 설명

• endRound(Long gameRoomId): 지정된 게임방의 현재 게임 라운드를 종료하고 결과를 반환합니다. 승자에게 포인트를 할당하고 라운드 상태를 초기화합니다.
• endGame(Long gameRoomId): 게임방의 게임을 종료하고 최종 결과를 반환합니다. 승자와 패자를 결정하고 게임 관련 데이터를 초기화합니다.
• determineGameResult(Game game): 게임의 카드를 비교하여 라운드의 승자와 패자를 결정합니다.
• assignRoundPointsToWinner(Game game, GameResult gameResult): 라운드 승자에게 포인트를 할당합니다.
• determineGameState(Game game): 게임의 현재 라운드 수를 기반으로 게임의 다음 상태를 결정합니다.
• processGameResults(Game game): 게임 결과를 처리하고 승자와 패자에게 적절한 포인트를 할당합니다.
• initializeTurnForGame(Game game, Long winnerId): 다음 라운드 또는 게임의 턴을 초기화합니다.

코드 리뷰

장점

• 모듈화: 각 기능별로 메서드가 잘 분리되어 있어, 각 기능의 로직을 이해하기 쉽고 유지 보수가 용이합니다.
• 효율적인 상태 관리: 트랜잭션 관리를 통해 데이터의 일관성을 유지하며, 각 게임 및 라운드의 상태를 체계적으로 업데이트합니다.

개선 사항

• 에러 처리: 현재 메서드들에서 발생할 수 있는 예외 사항들에 대한 처리가 충분히 강화될 필요가 있습니다. 특히, 게임의 규칙이나 로직 변경에 따라 예외 처리 로직을 추가하거나 수정할 필요가 있습니다.
• 성능 최적화: determineGameResult와 같은 메서드에서 카드 비교 로직이 더 효율적으로 처리될 수 있도록 최적화할 수 있습니다.
• 사용자 입력 처리: 사용자의 게임 내 행동에 대한 입력 처리 방식을 더욱 간소화하고 안전하게 처리할 방법을 모색해야  합니다. 현재는 입력과 관련된 복잡성이 서비스 레벨에서 다루어지지 않고 있습니다.

결론

EndGameService는 게임의 라운드 및 게임 종료 프로세스를 효과적으로 관리하며, 게임 로직의 핵심 부분을 담당하는 중요한 서비스입니다. 이 서비스는 게임의 흐름을 제어하고 게임의 결과를 관리하는 데 중추적인 역할을 합니다. 코드의 개선을 통해 더욱 견고하고 효율적인 게임 서비스를 구현할 수 있을 것입니다.

 

GameTurnService

package com.service.indianfrog.domain.game.service;

import com.service.indianfrog.domain.game.entity.Turn;
import com.service.indianfrog.domain.user.entity.User;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Tag(name = "게임 내 턴 관리 서비스 로직")
@Slf4j
@Service
public class GameTurnService {

    private final Map<Long, Turn> gameTurns = new ConcurrentHashMap<>();

    public void setTurn(Long gameId, Turn turn) {
        gameTurns.put(gameId, turn);
    }

    public Turn getTurn(Long gameId) {
        return gameTurns.get(gameId);
    }


}

 

GameTurnService 클래스는 게임 세션별로 플레이어의 턴을 관리하는 서비스입니다. 이 클래스는 각 게임의 ID를 키로 하여 Turn 객체를 저장하고 관리하는 ConcurrentHashMap을 사용합니다. 이러한 설계는 멀티스레드 환경에서 안전하게 턴 정보를 처리하고 접근할 수 있도록 해줍니다.

클래스 기능 및 메서드

• setTurn(Long gameId, Turn turn): 게임 ID에 해당하는 턴을 설정하거나 업데이트합니다. 게임의 진행 중에 턴 상태가 변경될 때 사용됩니다.
• getTurn(Long gameId): 주어진 게임 ID에 대한 현재 턴 정보를 반환합니다. 이 메서드는 게임 로직을 처리할 때 현재 누구의 턴인지 확인하는 데 사용됩니다.

코드 리뷰

장점

• 스레드 안전성: ConcurrentHashMap을 사용함으로써, 여러 스레드가 동시에 턴 정보에 접근하더라도 데이터 일관성과 안정성을 유지할 수 있습니다. 이는 특히 실시간 멀티플레이어 게임에서 중요합니다.
• 간결성: 클래스는 특정 게임의 턴을 관리하는 핵심 기능에 집중하고 있으며, 이는 단일 책임 원칙을 잘 따르고 있습니다.

개선 사항

• 예외 처리: getTurn 메서드에서 주어진 게임 ID에 대한 턴 정보가 없는 경우 null을 반환합니다. 이 경우 null 반환 대신 적절한 예외 처리나 옵셔널(Optional)을 사용하는 것이 더 좋은 에러 핸들링 방법이 될 수 있습니다.
• 로그 기능 확장: 현재 클래스에는 로그 기능이 명시적으로 보이지 않습니다. 메서드의 주요 실행 점에서 로그를 추가하여 턴 설정 및 검색 과정에서 발생하는 이벤트를 추적하는 것이 유용할 수 있습니다. 예를 들어, 턴을 설정하거나 검색할 때의 게임 ID와 턴 정보를 로그로 남겨 디버깅과 모니터링을 용이하게 할 수 있습니다.
• 성능 모니터링: 대규모 게임에서는 ConcurrentHashMap의 성능을 모니터링하고, 필요에 따라 더 효율적인 자료구조나 캐싱 전략을 고려할 수 있습니다.

결론

GameTurnService는 게임 내에서 턴 관리를 위한 중요한 서비스로, 게임의 흐름을 제어하고 플레이어 간 상호 작용을 조정하는 데 필수적인 역할을 합니다. 예외 처리와 로그 기능을 보강한다면 더욱 견고하고 안정적인 서비스를 제공할 수 있을 것입니다.

GameSessionService

package com.service.indianfrog.domain.game.service;

import com.service.indianfrog.domain.game.dto.GameStatus;
import com.service.indianfrog.domain.game.dto.UserChoices;
import com.service.indianfrog.domain.game.entity.GameState;
import com.service.indianfrog.domain.game.utils.GameValidator;
import com.service.indianfrog.domain.user.entity.User;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashSet;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Tag(name = "게임 종료 후 유저 선택 서비스 클래스", description = "게임 종료 후 유저의 선택에 따라 서비스를 수행하는 로직")
@Slf4j
@Service
public class GameSessionService {

    private final GameValidator gameValidator;
    public GameSessionService(GameValidator gameValidator) {
        this.gameValidator = gameValidator;
    }

    private final Map<Long, Map<String, String>> gameChoices = new ConcurrentHashMap<>();

    @Transactional
    public Object processUserChoices(Long gameRoomId, UserChoices choices) {
        /* 입력 값 검증*/
        gameValidator.validateAndRetrieveGameRoom(gameRoomId);
        User player = gameValidator.findUserByNickname(choices.getNickname());

        String nickname = player.getNickname();
        String choice = choices.getUserChoice().toString();

        /* 유저 선택 저장*/
        gameChoices.computeIfAbsent(gameRoomId, k -> new ConcurrentHashMap<>()).put(nickname, choice);

        /* 모든 유저의 선택이 완료되었는지 확인*/
        if (gameChoices.get(gameRoomId).size() == 2) {
            return new GameStatus(gameRoomId, nickname, determineActionAndProceed(gameRoomId));
        }

        return "다른 플레이어의 선택을 기다려주세요";
    }

    private GameState determineActionAndProceed(Long gameRoomId) {
        Map<String, String> roomChoices = gameChoices.get(gameRoomId);
        boolean allSame = new HashSet<>(roomChoices.values()).size() == 1;
        gameChoices.remove(gameRoomId);

        if (allSame) {
            return roomChoices.values().iterator().next().equals("PLAY_AGAIN") ? GameState.START : GameState.LEAVE;
        } else {
            return GameState.ENTER;
        }
    }
}

 

GameSessionService 클래스는 게임 종료 후 유저의 선택을 처리하는 서비스입니다. 이 서비스는 유저가 게임을 계속할지, 떠날지 결정하는 선택을 관리하고, 모든 유저의 선택이 완료되면 그에 따른 다음 단계를 진행합니다.

주요 기능 및 메소드

• processUserChoices(Long gameRoomId, UserChoices choices):
  • 게임방 ID와 유저 선택을 파라미터로 받아 유효성을 검사하고, 유저의 선택을 저장합니다.
  • 모든 유저의 선택이 완료되면 게임의 다음 상태를 결정하고, 그 결과를 반환합니다. 모든 유저가 동일한 선택을 했다면 PLAY_AGAIN일 경우 게임을 재시작하고, 그렇지 않으면 게임방을 떠납니다.
• determineActionAndProceed(Long gameRoomId):
  • 저장된 유저의 선택을 검토하여 게임의 다음 상태를 결정합니다. 모든 유저가 같은 선택을 한 경우에 따라 게임 상태를 변경합니다.

코드 리뷰

장점

• 병렬 처리와 동시성: ConcurrentHashMap을 사용하여 동시성을 보장하고, 여러 스레드에서 안전하게 유저 선택을 처리할 수 있도록 구현되었습니다.
• 모듈화와 단일 책임 원칙: 클래스는 유저 선택을 처리하는 명확한 책임을 가지고 있으며, 관련 로직이 잘 구성되어 있습니다.

개선 사항

• 예외 처리와 사용자 피드백: 모든 유저의 선택이 완료되지 않았을 때의 반환 메시지는 사용자에게 유용한 정보를 제공하지만, 예외 상황에 대한 더 구체적인 처리나 사용자 피드백을 제공할 수 있습니다.
• 유저 선택의 동기화와 상태 관리: 현재 구현에서는 간단한 방식으로 모든 유저의 선택을 확인하지만, 게임방에 여러 유저가 있는 복잡한 시나리오에서는 이 메커니즘을 더 발전시켜야 할 수 있습니다.
• 유저 선택의 다양성 고려: PLAY_AGAIN과 LEAVE 외의 다른 선택지에 대한 처리 방법을 고려하는 것이 좋을 수 있습니다. 예를 들어, 게임 설정을 변경하거나 다른 게임 옵션을 선택하는 경우 등을 처리할 수 있어야 합니다.

결론

GameSessionService는 게임 종료 후 유저의 선택을 효과적으로 처리하는 중요한 역할을 수행합니다. 이 서비스를 통해 게임의 흐름과 유저 간의 상호작용을 효율적으로 관리할 수 있습니다. 개선 사항을 통해 서비스의 견고성과 사용자 경험을 향상시킬 수 있을 것입니다.