[5기] 3주차 Wordle 과제 제출 - 얄뭉

README.md

@@ -1,5 +1,10 @@
 # 미션 - 워들
 
+## 🙆🏻‍♀️페어 구성🙆🏻
+- 점프
+- 얄뭉
+---
+
 ## 🔍 진행 방식
 
 - 미션은 **과제 진행 요구 사항**, **기능 요구 사항**, **프로그래밍 요구 사항** 세 가지로 구성되어 있다.
@@ -12,13 +17,16 @@
 
 선풍적인 인기를 끌었던 영어 단어 맞추기 게임이다.
 
-- 6x5 격자를 통해서 5글자 단어를 6번 만에 추측한다.
-- 플레이어가 답안을 제출하면 프로그램이 정답과 제출된 단어의 각 알파벳 종류와 위치를 비교해 판별한다.
-- 판별 결과는 흰색의 타일이 세 가지 색(초록색/노란색/회색) 중 하나로 바뀌면서 표현된다.
-    - 맞는 글자는 초록색, 위치가 틀리면 노란색, 없으면 회색
+- [x] 게임 진행 메시지를 출력한다.
+- [x] 격자를 통해서 5글자 단어를 6번 만에 추측한다.
+- [x] 플레이어가 답안을 제출하면 프로그램이 정답과 제출된 단어의 각 알파벳 종류와 위치를 비교해 판별한다.
+  - [x] 입력 단어는 영단어야 한다.
+  - [x] 단어의 수는 5글자여야 한다.
+  - [x] 단어는 `words.txt`에 포함된 단어여야 한다.
+- [x] 판별 결과는 흰색의 타일이 세 가지 색(초록색/노란색/회색) 중 하나로 바뀌면서 표현된다.
+    - 맞는 글자는 초록색(🟩), 위치가 틀리면 노란색(🟨), 없으면 회색(⬜)
     - 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 나타난다.
-- 정답과 답안은 `words.txt`에 존재하는 단어여야 한다.
-- 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
+- [x] 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
 
 ### 입출력 요구 사항
 
@@ -87,3 +95,36 @@ spill
 - 도메인 로직에 단위 테스트를 구현해야 한다. 단, UI(System.out, System.in, Scanner) 로직은 제외한다.
     - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 분리해 구현한다.
     - 힌트: MVC 패턴 기반으로 구현한 후, View와 Controller를 제외한 Model에 대한 단위 테스트 추가에 집중한다.
+---
+### 구현 목록
+- 단어 불러오기
+- 매일 바뀌는 정답단어 선택
+- 단어 입력
+  - 입력시 단어목록에 있나 검증
+- 비교 로직
+  - 같을때, 있을떄, 없을때 따른 비교결과
+- 게임로직
+  - 6회 초과시 게임오버
+  - 정답시 게임클리어
+- ui
+  - 비교 결과, 라운드 출력
+
+---
+### 리팩터링 포인트
+- [x] final 붙혀주기
+- [x] Inputword 에 availableWords 상태로 가지고 있을 필요는 없다.
+- [x] InputWord와 Answer를 합치기?
+- [x] match 에 for 문안 함수로 발라내기
+- [x] isEndGame 플래그 변수 네이밍 변경
+  - [x] 검증
+  - [x] 5글자 검증
+- [x] 영단어 검증
+- [x] 예외 try catch
+- [x] GameManager에 있는 List 의 변수명 변경
+- [x] HintView에 3depth 줄이기
+- [x] InputWord의 마지막 테스트함수 이름
+- [x] MatchResult에 inputChar가 쓰이지 않고 있어서 클래스 자체를 지우고 그냥 Hint만 쓰기
+- ~~- 구조 변경~~
+  - ~~-  GameManager의 의존성 줄여두기~~
+  - ~~-String 말고 char 배열로 쓸지? -> 좀 더 고민해보기~~
+  - ~~-분리된 view 부분 합칠지?~~

src/main/java/WordleApplication.java

@@ -0,0 +1,15 @@
+import config.FileConfig;
+import controller.GameManager;
+import infra.WordLoader;
+
+import java.util.List;
+
+public class WordleApplication {
+    public static void main(String[] args) {
+
+        List<String> words = WordLoader.read(FileConfig.FILE_PATH);
+        GameManager gameManager = new GameManager(words);
+        gameManager.start();
+    }
+
+}

src/main/java/config/FileConfig.java

@@ -0,0 +1,8 @@
+package config;
+
+public class FileConfig {
+
+    protected FileConfig() {
+    }
+    public static final String FILE_PATH = "src/main/resources/words.txt";
+}

src/main/java/controller/GameManager.java

@@ -0,0 +1,86 @@
+package controller;
+
+import domain.MatchResult;
+import domain.MatchResults;
+import domain.Round;
+import domain.Word;
+import ui.GuideTextView;
+import ui.HintView;
+import ui.InputView;
+import ui.RoundView;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public class GameManager {
+
+    private final static int LIMIT = 6;
+    private final static int CURRENT = 1;
+    private final Round round;
+    private final MatchResults matchResults;
+    private final Word answer;
+    private final GuideTextView guideTextView;
+    private final InputView inputView;
+    private final HintView hintView;
+    private final RoundView roundView;
+    private final List<String> availableWords;
+    private boolean isWinning = false;
+
+    public GameManager(List<String> availableWords) {
+        this.answer = Word.createAnswer(LocalDate.now(), availableWords);
+        this.availableWords = availableWords;
+        this.round = new Round(LIMIT, CURRENT);
+        this.matchResults = new MatchResults();
+        this.guideTextView = new GuideTextView();
+        this.inputView = new InputView();
+        this.hintView = new HintView();
+        this.roundView = new RoundView();
+    }
+    public void start() {
+        guideTextView.render();
+        while(!this.isWinning && round.isNotFinalRound()) {
+            startRound();
+        }
+    }
+
+    private void startRound() {
+        Word inputWord = null;
+        boolean canCreateInputWord = false;
+
+        while (!canCreateInputWord) {
+            String input = inputView.input();
+            inputWord = Word.createInput(input, this.availableWords);
+            canCreateInputWord = inputWord.getAvailableWord();
+        }
+
+        checkAnswer(inputWord);
+        renderResult();
+        round.goNext();
+    }
+
+    private void renderResult() {
+        checkRenderRound();
+        hintView.render(matchResults);
+        checkFinalRound();
+    }
+
+    private void checkRenderRound() {
+        if(this.isWinning || !round.isNotFinalRound()) {
+            roundView.render(round.getCurrent(),round.getLimit());
+        }
+    }
+
+    private void checkFinalRound() {
+        if(!this.isWinning && round.isFinalRound()) {
+            roundView.render(round.getCurrent(),round.getLimit());
+            roundView.renderLoseGame();;
+        }
+    }
+
+    private void checkAnswer(Word inputWord) {
+        MatchResult matchResultOfInput = answer.match(inputWord);
+        this.matchResults.add(matchResultOfInput);
+        this.isWinning = matchResultOfInput.isEndGame();
+    }
+
+}

src/main/java/domain/Hint.java

@@ -0,0 +1,20 @@
+package domain;
+
+public enum Hint {
+    CORRECT("🟩"),           // \uD83D\uDFE9
+    EXIST("🟨"),             // \uD83D\uDFE8
+    NOT_EXIST("⬜");
+    private final String tile;
+
+    Hint(String tile) {
+        this.tile = tile;
+    }
+
+    public String getTile() {
+        return tile;
+    }
+
+    public static boolean isCorrect(Hint hint) {
+        return Hint.CORRECT.equals(hint);
+    }
+}

src/main/java/domain/HintLetter.java

@@ -0,0 +1,44 @@
+package domain;
+
+import java.util.List;
+import java.util.Objects;
+
+public class HintLetter {
+    private final Character letter;
+
+    private Hint hint;
+
+    public HintLetter(Character letter, Hint hint) {
+        this.letter = letter;
+        this.hint = hint;
+    }
+
+    public void changeCorrectToNotExist(List<Character> correctedChar) {
+        if(correctedChar.contains(letter) && !isCorrectHint()) {
+            this.hint = Hint.NOT_EXIST;
+        }
+    }
+
+    public boolean isCorrectHint() {
+        return Hint.isCorrect(hint);
+    }
+
+    public String getHintTile() {
+        return hint.getTile();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        HintLetter that = (HintLetter) o;
+        return Objects.equals(letter, that.letter) && hint == that.hint;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(letter, hint);
+    }
+}
+
+

src/main/java/domain/MatchResult.java

@@ -0,0 +1,42 @@
+package domain;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class MatchResult {
+    private final List<HintLetter> hints;
+    public MatchResult(List<HintLetter> hints) {
+        this.hints = hints;
+    }
+
+    public boolean isEndGame() {
+        return hints.stream()
+                .allMatch(HintLetter::isCorrectHint);
+    }
+    public void add(HintLetter hintLetter) {
+        hints.add(hintLetter);
+    }
+
+    public String getHintTiles() {
+        return hints.stream()
+                .map(HintLetter::getHintTile)
+                .collect(Collectors.joining());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        MatchResult that = (MatchResult) o;
+        return Objects.equals(hints, that.hints);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(hints);
+    }
+}
+
+

src/main/java/domain/MatchResults.java

@@ -0,0 +1,19 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class MatchResults implements Iterable<MatchResult> {
+    private final List<MatchResult> results;
+    public MatchResults() {
+        this.results = new ArrayList<>();
+    }
+    public void add(MatchResult matchResultOfInput) {
+        this.results.add(matchResultOfInput);
+    }
+    @Override
+    public Iterator<MatchResult> iterator() {
+        return this.results.iterator();
+    }
+}

src/main/java/domain/Round.java

@@ -0,0 +1,31 @@
+package domain;
+
+public class Round {
+    private final int limit;
+    private int current;
+
+    public Round(int limit, int current) {
+        this.limit = limit;
+        this.current = current;
+    }
+
+    public void goNext() {
+        this.current++;
+    }
+
+    public int getLimit() {
+        return limit;
+    }
+
+    public int getCurrent() {
+        return current;
+    }
+
+    public boolean isNotFinalRound() {
+        return current <= limit;
+    }
+
+    public boolean isFinalRound() {
+        return current == limit;
+    }
+}