[Wordle] 돌쓰팀(yooth) 미션 제출합니다.

build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    kotlin("jvm") version "1.9.0"
+    kotlin("jvm") version "1.9.23"
     id("org.jlleitschuh.gradle.ktlint") version "12.1.0"
 }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/kotlin/wordle/Application.kt

@@ -0,0 +1,7 @@
+package wordle
+
+import wordle.controller.WordleGameController
+
+fun main() {
+    WordleGameController().run()
+}

src/main/kotlin/wordle/controller/WordleGameController.kt

@@ -0,0 +1,13 @@
+package wordle.controller
+
+import wordle.domain.TodayWord
+import wordle.domain.WordleGame
+import wordle.view.printWelcome
+import java.time.LocalDate
+
+class WordleGameController {
+    fun run() {
+        printWelcome()
+        WordleGame().play(TodayWord(LocalDate.now()))
+    }
+}

src/main/kotlin/wordle/domain/Letter.kt

@@ -0,0 +1,27 @@
+package wordle.domain
+
+import wordle.exception.ExceptionMessage.INVALID_LETTER
+
+data class Letter(private val value: Char) {
+    init {
+        check(isAlphabetOrMatchMarker()) { INVALID_LETTER.message }
+    }
+
+    fun changeMatchMarker(): Letter = MATCH_MARKER_LETTER
+
+    fun value(): String {
+        return value.toString()
+    }
+
+    private fun isAlphabetOrMatchMarker(): Boolean = isAlphabet() || isMatchMarker()
+
+    private fun isAlphabet(): Boolean = (value in ALPHABET)
+
+    private fun isMatchMarker(): Boolean = (value == MATCH_MARKER)
+
+    companion object {
+        private const val MATCH_MARKER = '#'
+        private val ALPHABET = ('a'..'z').toSet()
+        private val MATCH_MARKER_LETTER = Letter(MATCH_MARKER)
+    }
+}

src/main/kotlin/wordle/domain/LetterMatch.kt

@@ -0,0 +1,7 @@
+package wordle.domain
+
+enum class LetterMatch {
+    CORRECT,
+    PRESENT,
+    ABSENT,
+}

src/main/kotlin/wordle/domain/TodayWord.kt

@@ -0,0 +1,15 @@
+package wordle.domain
+
+import wordle.loader.dictionaryWordsSize
+import wordle.loader.indexOfDictionaryWord
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+private val CRITERION_DATE: LocalDate = LocalDate.of(2021, 6, 19)
+
+fun extractWordleWord(date: LocalDate): String {
+    val between = ChronoUnit.DAYS.between(CRITERION_DATE, date)
+    val index = (between % dictionaryWordsSize).toInt()
+
+    return indexOfDictionaryWord(index)
+}

src/main/kotlin/wordle/domain/TryCount.kt

@@ -0,0 +1,16 @@
+package wordle.domain
+
+import wordle.exception.ExceptionMessage
+
+class TryCount(private var count: Int = MAX_TRY_COUNT) {
+    val attempts get() = MAX_TRY_COUNT - count
+
+    fun isRemainder(): Boolean = count > 0
+
+    fun minus() {
+        check(isRemainder()) { ExceptionMessage.TRY_COUNT_HAS_NOT_REMAINDER.message }
+        --count
+    }
+}
+
+const val MAX_TRY_COUNT = 6

src/main/kotlin/wordle/domain/Word.kt

@@ -0,0 +1,40 @@
+package wordle.domain
+
+import wordle.exception.ExceptionMessage
+import wordle.loader.isContainsDictionaryWord
+import java.time.LocalDate
+
+typealias TodayWord = Word
+
+class Word(private val word: List<Letter>) : List<Letter> by word {
+    fun letters(): String {
+        return word.joinToString("", transform = Letter::value)
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as Word
+
+        return word == other.word
+    }
+
+    override fun hashCode(): Int {
+        return word.hashCode()
+    }
+}
+
+const val WORD_LENGTH = 5
+
+fun Word(word: String): Word {
+    check(word.isNotBlank()) { ExceptionMessage.WORD_NOT_BLANK.message }
+    check(word.length == WORD_LENGTH) { ExceptionMessage.INVALID_WORD_LENGTH.message }
+    check(isContainsDictionaryWord(word)) { ExceptionMessage.WORD_NOT_FOUND.message }
+
+    return Word(word.toCharArray().map { Letter(it) })
+}
+
+fun TodayWord(today: LocalDate): TodayWord {
+    return Word(extractWordleWord(today))
+}

src/main/kotlin/wordle/domain/WordComparator.kt

@@ -0,0 +1,66 @@
+package wordle.domain
+
+class WordComparator(
+    private val letters: MutableList<Letter>,
+    private val wordResult: WordResult = WordResult(),
+) {
+    fun matchCorrect(answerWord: Word): WordComparator =
+        apply {
+            letters.forEachIndexed { index, _ ->
+                changeCorrectMatch(index, answerWord[index])
+            }
+        }
+
+    fun matchPresent(answerWord: Word): WordComparator =
+        apply {
+            letters.forEachIndexed { index, _ ->
+                changePresentMatch(index, answerWord[index])
+            }
+        }
+
+    fun result(): WordResult = wordResult
+
+    private fun changeCorrectMatch(
+        index: Int,
+        letter: Letter,
+    ) {
+        if (isCorrectLetter(index, letter)) {
+            wordResult.changeMatchType(index, LetterMatch.CORRECT)
+            changeLetter(index)
+        }
+    }
+
+    private fun changePresentMatch(
+        index: Int,
+        letter: Letter,
+    ) {
+        if (isPresentLatter(index, letter)) {
+            wordResult.changeMatchType(index, LetterMatch.PRESENT)
+            changeLetters(letter)
+        }
+    }
+
+    private fun isCorrectLetter(
+        index: Int,
+        letter: Letter,
+    ) = letters[index] == letter
+
+    private fun isPresentLatter(
+        index: Int,
+        letter: Letter,
+    ) = !isCorrectLetter(index, letter) && contains(letter)
+
+    private fun changeLetter(index: Int) {
+        letters[index] = letters[index].changeMatchMarker()
+    }
+
+    private fun changeLetters(letter: Letter) {
+        changeLetter(letters.indexOf(letter))
+    }
+
+    private fun contains(letter: Letter) = letter in letters
+}
+
+fun WordComparator(todayWord: Word): WordComparator {
+    return WordComparator(todayWord.map(Letter::copy).toMutableList())
+}

src/main/kotlin/wordle/domain/WordResult.kt

@@ -0,0 +1,20 @@
+package wordle.domain
+
+import wordle.exception.ExceptionMessage
+
+data class WordResult(private val result: MutableList<LetterMatch> = MutableList(WORD_LENGTH) { LetterMatch.ABSENT }) {
+    init {
+        check(result.size == WORD_LENGTH) { ExceptionMessage.INVALID_WORD_RESULT_LENGTH.message }
+    }
+
+    fun isSuccessGame() = result.all { matchType -> matchType == LetterMatch.CORRECT }
+
+    fun changeMatchType(
+        index: Int,
+        matchType: LetterMatch,
+    ) {
+        result[index] = matchType
+    }
+
+    fun matches(): List<LetterMatch> = result.toList()
+}

src/main/kotlin/wordle/domain/WordResults.kt

@@ -0,0 +1,19 @@
+package wordle.domain
+
+class WordResults(
+    private val results: MutableList<WordResult> = mutableListOf(),
+    private val tryCount: TryCount = TryCount(),
+) {
+    val attemptCount get() = tryCount.attempts
+
+    fun addResults(result: WordResult) {
+        tryCount.minus()
+        results.add(result)
+    }
+
+    fun isContinuousGame(): Boolean = !isSuccessGame() && tryCount.isRemainder()
+
+    fun isSuccessGame(): Boolean = results.any(WordResult::isSuccessGame)
+
+    fun wordResults(): List<List<LetterMatch>> = results.map(WordResult::matches)
+}

src/main/kotlin/wordle/domain/WordleGame.kt

@@ -0,0 +1,36 @@
+package wordle.domain
+
+import wordle.view.inputAnswer
+import wordle.view.printFail
+import wordle.view.printResult
+import wordle.view.printRetry
+import wordle.view.printSuccess
+
+class WordleGame {
+    private val results = WordResults()
+
+    fun play(todayWord: TodayWord) {
+        val wordleGameLogic = WordleGameLogic(todayWord)
+
+        while (results.isContinuousGame()) {
+            val answer = inputAnswer()
+            try {
+                val answerWord = Word(answer)
+                val result = wordleGameLogic.compare(answerWord)
+                results.addResults(result)
+                printResult(results)
+            } catch (e: IllegalStateException) {
+                printRetry(e.message)
+            }
+        }
+        gameResult(todayWord)
+    }
+
+    private fun gameResult(todayWord: Word) {
+        if (results.isSuccessGame()) {
+            printSuccess(results.attemptCount)
+            return
+        }
+        printFail(todayWord)
+    }
+}

src/main/kotlin/wordle/domain/WordleGameLogic.kt

@@ -0,0 +1,11 @@
+package wordle.domain
+
+class WordleGameLogic(private val todayWord: Word) {
+    fun compare(answerWord: Word): WordResult =
+        todayWord.comparator()
+            .matchCorrect(answerWord)
+            .matchPresent((answerWord))
+            .result()
+
+    private fun Word.comparator(): WordComparator = WordComparator(this)
+}

src/main/kotlin/wordle/exception/ExceptionMessage.kt

@@ -0,0 +1,12 @@
+package wordle.exception
+
+import wordle.domain.WORD_LENGTH
+
+enum class ExceptionMessage(val message: String) {
+    INVALID_LETTER("유효하지 않은 글자입니다."),
+    WORD_NOT_BLANK("단어는 공백을 허용하지 않습니다."),
+    INVALID_WORD_LENGTH("단어는 ${WORD_LENGTH}자 이여야만 합니다."),
+    WORD_NOT_FOUND("단어사전에 없는 단어입니다."),
+    TRY_COUNT_HAS_NOT_REMAINDER("시행 횟수는 0보다 작을 수 없습니다."),
+    INVALID_WORD_RESULT_LENGTH("단어 비교 결과는 단어 길이($WORD_LENGTH)와 일치해야 합니다."),
+}

src/main/kotlin/wordle/loader/DictionaryFileLoader.kt

@@ -0,0 +1,16 @@
+package wordle.loader
+
+import java.io.File
+
+private const val CARRIAGE_RETURN = "\n"
+private const val WORDS_FILE_PATH = "src/main/resources/words.txt"
+private val dictionaryWords: List<String> by lazy { load() }
+val dictionaryWordsSize: Int get() = dictionaryWords.size
+
+fun isContainsDictionaryWord(word: String): Boolean = dictionaryWords.contains(word)
+
+fun indexOfDictionaryWord(index: Int): String = dictionaryWords[index]
+
+private fun load(): List<String> =
+    File(WORDS_FILE_PATH).readText()
+        .split(CARRIAGE_RETURN)

src/main/kotlin/wordle/view/InputView.kt

@@ -0,0 +1,6 @@
+package wordle.view
+
+fun inputAnswer(): String {
+    println("🚀 정답을 입력하세요. : ")
+    return readln()
+}

src/main/kotlin/wordle/view/OutputView.kt

@@ -0,0 +1,25 @@
+package wordle.view
+
+import wordle.domain.MAX_TRY_COUNT
+import wordle.domain.Word
+import wordle.domain.WordResults
+
+fun printWelcome() {
+    println("🥳 WORDLE을 6번 만에 맞춰 보세요.\n시도의 결과는 타일의 색 변화로 나타납니다.\n")
+}
+
+fun printResult(results: WordResults) {
+    println(results.wordResults().joinToString("\n") { it.joinToString("") { Tile.of(it).color } } + "\n")
+}
+
+fun printFail(todayWord: Word) {
+    println("오늘의 단어는 ${todayWord.letters()} 입니다.")
+}
+
+fun printSuccess(attemptCount: Int) {
+    println("성공입니다. $attemptCount / $MAX_TRY_COUNT")
+}
+
+fun printRetry(message: String?) {
+    println("🥲 다시 시도하세요! : ${message ?: ""}\n")
+}

src/main/kotlin/wordle/view/Tile.kt

@@ -0,0 +1,16 @@
+package wordle.view
+
+import wordle.domain.LetterMatch
+
+enum class Tile(val matchType: LetterMatch, val color: String) {
+    GREEN(LetterMatch.CORRECT, "🟩"),
+    YELLOW(LetterMatch.PRESENT, "🟨"),
+    GREY(LetterMatch.ABSENT, "⬜"),
+    ;
+
+    companion object {
+        fun of(matchType: LetterMatch): Tile {
+            return entries.find { tile -> tile.matchType == matchType } ?: GREY
+        }
+    }
+}