🪜사다리 게임 # 2022.04.18~2022.05.02

🎈 구현 기능 목록

• 입력
  • 참여자 이름
  • 실행 결과
  • 최대 사다리 높이
  • 결과 보고싶은 사람 이름 (개인 or all)
• 출력
  • 사다리 결과
    • 하나의 가로 라인을 가지고 있는 Line Class
    • 하나의 세로 라인에 빈 값이 없도록 가로 라인을 생성하는 로직 추가
    • 최대 사다리 높이만큼 Line을 가지고 있는 Ladder Class
  • 실행 결과 (개인 or all)
    • 라인을 따라 player의 위치를 이동 시켜 실행 결과를 생성하는 로직 추가

🚀 기능 요구 사항

• 사다리 게임에 참여하는 사람에 이름을 최대5글자까지 부여할 수 있다. 사다리를 출력할 때 사람 이름도 같이 출력한다.
• 사람 이름은 쉼표(,)를 기준으로 구분한다.
• 사람 이름을 5자 기준으로 출력하기 때문에 사다리 폭도 넓어져야 한다.
• 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
  • |-----|-----| 모양과 같이 가로 라인이 겹치는 경우 어느 방향으로 이동할지 결정할 수 없다.
• 사다리 실행 결과를 출력해야 한다.
• 개인별 이름을 입력하면 개인별 결과를 출력하고, "all"을 입력하면 전체 참여자의 실행 결과를 출력한다.

🚀 구현해야 할 기능

• 위 요구사항에 따라 4명의 사람을 위한 5개 높이 사다리를 만들 경우, 프로그램을 실행한 결과는 다음과 같다.

참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)
dowon, halim, geinee, dowon2

실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)
꽝,5000,꽝,3000

최대 사다리 높이는 몇 개인가요?
5

사다리 결과

dowon  halim  geinee dowon2
    |-----|     |-----|
    |     |-----|     |
    |-----|     |     |
    |     |-----|     |
    |-----|     |-----|
    꽝    5000  꽝    3000

결과를 보고 싶은 사람은?
dowon

실행 결과
꽝

결과를 보고 싶은 사람은?
all

실행 결과
dowon : 꽝
halim : 3000
geinee : 꽝
dowon2 : 5000

 

###

- 메서드 선언 규칙

1.

생성자
static 메서드
public 메서드
private 메서드
getter 메서드

2.

생성자
static 메서드
public 메서드
위 public메서드에서 호출하는 private 메서드들
public 메서드
위 public메서드에서 호출하는 private 메서드들
반복..
getter 메서드

 

- Random 객체 nextBoolean() 

- 배열보다는 java Collection(List, Map, Set) 사용

- 숫자 상수 선언

- stream 사용

before

after

- 테스트 커버리지 활용

- for, if문 등 한줄 중괄호 생략 x 

 

main controller 

public class LadderGame {
    public static final String ALL = "all";

    public void play() {
        Players players = createPlayers();
        int playerCount = players.getPlayerCount();
        Prizes prizes = createPrizes(playerCount);
        int height = inputHeight();

        Ladder ladder = new Ladder(playerCount, height);

        printLadder(players, ladder, prizes);
        GameResult gameResult = createGameResult(players, ladder, prizes);
        printGameResult(gameResult);
    }

    private Players createPlayers() {
        String[] names;
        Players players;

        do {
            names = inputPlayersNames();
            players = new Players(names);
        } while (!players.isValidNameLength(names) || !players.isValidPlayerCount(names));

        return players;
    }

    private String[] inputPlayersNames() {
        String names = InputView.inputPlayersNames();
        return Convert.splitNames(names);
    }

    private Prizes createPrizes(int playerCount) {
        String[] prize;
        Prizes prizes;

        do {
            prize = inputPrizes();
            prizes = new Prizes(prize);
        } while (!prizes.isValidPrizeCount(prize, playerCount));

        return prizes;
    }

    private String[] inputPrizes() {
        String prizes = InputView.inputPrizes();
        return Convert.splitNames(prizes);
    }

    private int inputHeight() {
        return InputView.inputHeight();
    }

    private void printLadder(Players players, Ladder ladder, Prizes prizes) {
        OutputView.printPlayersNames(players.getPlayers());

        for (Line line : ladder.getLadder()) {
            OutputView.printLine(line.getLine());
        }

        OutputView.printPrizes(prizes.getPrizes());
    }

    private GameResult createGameResult(Players players, Ladder ladder, Prizes prizes) {
        GameResultCreator gameResultCreator = new GameResultCreator(players.getPlayers(), ladder.getLadder(), prizes.getPrizes());
        return new GameResult(gameResultCreator.getGameResult());
    }

    private void printGameResult(GameResult gameResult) {
        do {
            String name = InputView.inputPeopleResultRequest();
            if (name.equals(ALL)) {
                break;
            }

            printPlayerResult(gameResult, name);
        } while (true);

        OutputView.printAllGameResult(gameResult.getGameResult());
    }

    private void printPlayerResult(GameResult gameResult, String name) {
        Map<String, String> results = gameResult.getGameResult();

        if (results.get(name) == null) {
            System.out.println("해당 플레이어는 존재하지 않습니다. \n다시 입력 해 주세요.");
            return;
        }

        OutputView.printOnePeopleGameResult(gameResult.getGameResult(), name);
    }
}

model.GameResultCreator

public class GameResultCreator {
    private final Map<String, String> gameResult;

    public GameResultCreator(List<String> players, List<Line> lines, List<String> prizes) {
        this.gameResult = createGameResult(players, lines, prizes);
    }

    private Map<String, String> createGameResult(List<String> players, List<Line> lines, List<String> prizes) {
        Map<String, String> gameResult = new HashMap<>();

        for (int i = 0; i < players.size(); i++) {
            int finalPlayerLocationIdx = findFinalPlayerLocationIdx(lines, i);

            String playerName = players.get(i);
            String prize = prizes.get(finalPlayerLocationIdx);
            gameResult.put(playerName, prize);
        }

        return gameResult;
    }

    private int findFinalPlayerLocationIdx(List<Line> lines, int playerStartIdx) {
        int location = playerStartIdx;
        int height = 0;

        while (height < lines.size()) {
            Line line = lines.get(height);
            location = updateLocation(line, location);
            height++;
        }

        return location;
    }

    private int updateLocation(Line line, int location) {
        int lastIdx = line.getLine().size();

        if (location == 0) {
            location = updateRightDirection(line.getLine(), location);
            return location;
        }

        if (location == lastIdx) {
            location = updateLeftDirection(line.getLine(), location);
            return location;
        }

        int newLocation = updateRightDirection(line.getLine(), location);

        return newLocation != location ? newLocation : updateLeftDirection(line.getLine(), location);
    }

    private int updateRightDirection(List<Boolean> points, int location) {
        boolean rightPoint = points.get(location);
        return rightPoint ? location + 1 : location;
    }

    private int updateLeftDirection(List<Boolean> points, int location) {
        boolean leftPoint = points.get(location - 1);
        return leftPoint ? location - 1 : location;
    }

    public Map<String, String> getGameResult() {
        return this.gameResult;
    }
}

model.Line

public class Line {
    private final List<Boolean> line;

    public Line(int width) {
        this.line = createLine(width);
    }

    private List<Boolean> createLine(int width) {
        Random random = new Random();
        List<Boolean> points = new ArrayList<>();

        for (int i = 0; i < width; i++) {
            points.add(random.nextBoolean());
        }

        return createValidLine(points);
    }

    private List<Boolean> createValidLine(List<Boolean> points) {
        int width = points.size();

        for (int i = 0; i < width; i++) {
            modifyPoint(points, i);
        }

        return points;
    }

    private void modifyPoint(List<Boolean> points, int pointIdx) {
        int width = points.size();
        int lastIdx = width - 1;

        if (pointIdx != lastIdx && isValidPoints(points, pointIdx)) {
            points.set(pointIdx + 1, false);
        }
    }

    private boolean isValidPoints(List<Boolean> points, int index) {
        return points.get(index) && points.get(index + 1);
    }

    public List<Boolean> getLine() {
        return this.line;
    }
}

model.Lines

public class Lines {
    private final List<Line> lines;

    public Lines(int width, int height) {
        this.lines = createValidLines(width, height);
    }

    private List<Line> createValidLines(int width, int height) {
        List<Line> lines;
        boolean replay;

        do {
            lines = createRandomLines(width, height);
            List<Integer> count = calculateBridgesCounts(lines, width, height);

            replay = count.stream()
                    .anyMatch(bridgeCount -> bridgeCount == 0);
        } while (replay);

        return lines;
    }

    private List<Line> createRandomLines(int width, int height) {
        List<Line> lines = new ArrayList<>();

        for (int i = 0; i < height; i++)
            lines.add(new Line(width));

        return lines;
    }

    private List<Integer> calculateBridgesCounts(List<Line> lines, int width, int height) {
        List<Integer> bridgesCounts = new ArrayList<>();

        for (int i = 0; i < width; i++) {
            int bridgeCount = getBridgeCount(lines, i, height);
            bridgesCounts.add(bridgeCount);
        }

        return bridgesCounts;
    }

    private int getBridgeCount(List<Line> lines, int index, int height) {
        int count = 0;

        for (int i = 0; i < height; i++) {
            Line line = lines.get(i);
            List<Boolean> points = line.getLine();
            count = updateBridgeCount(points.get(index), count);
        }

        return count;
    }

    private int updateBridgeCount(boolean point, int count) {
        return point ? count + 1 : count;
    }

    public List<Line> getLines() {
        return this.lines;
    }

}