[Wordle] 제로(공재호) 미션 제출합니다.

README.md

@@ -8,6 +8,29 @@
 
 ---
 
+🛠 기능 목록
+- [x]  정답 매칭
+    - [x]  판별 결과는 타일로 알려준다.
+    - [x]  정답은 `words.txt`의 ((현재 날짜 - 2021년 6월 19일) % `words.txt`의 단어 개수) 번째의 단어이다.
+    - [x]  매칭 결과
+        - [x]  플레이어 답과 정답 사이 한 글자의 스펠과 위치가 같은 경우 `초록색 타일`로 나타낸다.
+        - [x]  플레이어 답과 정답 사이 한 글자의 스펠은 같지만 위치가 다른 경우 `노란색 타일`로 나타낸다.
+        - [x]  플레이어 답과 정답 사이 한 글자의 스펠과 위치가 모두 다른 경우 `회색 타일`로 나타낸다.
+- [x]  타일
+    - [x]  초록색, 노란색, 회색
+- [x]  단어
+    - [x]  단어는 5글자이다.
+    - [x]  단어는 영단어이다.
+- [x]  게임
+    - [x]  최대 6번까지 답안을 제출할 수 있다.
+        - [x]  정답은 `words.txt`의 ((현재 날짜 - 2021년 6월 19일) % `words.txt`의 단어 개수) 번째의 단어이다.
+        - [x]  단어는 `words.txt`에 포함된 단어여야 한다.
+        - [x]  답안을 6번 제출하면 게임을 종료한다.
+        - [x]  6번 안에 정답을 맞추면 종료한다.
+    - [x]  플레이어는 답을 입력한다.
+        - [x]  답을 입력할때마다 매칭된 누적 타일을 반환한다.
+    - [x]  게임이 종료되면 시도횟수를 반환한다.
+
 ## 🚀 기능 요구 사항
 
 선풍적인 인기를 끌었던 영어 단어 맞추기 게임이다.

src/main/kotlin/study/Introduce.kt

@@ -0,0 +1,8 @@
+package study
+
+import study.person.Person
+import study.person.PersonBuilder
+
+fun introduce(builder: PersonBuilder.() -> Unit): Person {
+    return PersonBuilder().apply(builder).build()
+}

src/main/kotlin/study/language/Language.kt

@@ -0,0 +1,3 @@
+package study.language
+
+data class Language(val name: String, val level: Int)

src/main/kotlin/study/language/LanguageBuilder.kt

@@ -0,0 +1,14 @@
+package study.language
+
+class LanguageBuilder {
+
+    var languages: MutableList<Language> = mutableListOf()
+
+    infix fun String.level(level: Int) {
+        languages.add(Language(this, level))
+    }
+
+    fun build(): MutableList<Language> {
+        return languages
+    }
+}

src/main/kotlin/study/person/Person.kt

@@ -0,0 +1,11 @@
+package study.person
+
+import study.language.Language
+import study.skill.Skill
+
+data class Person(
+    val name: String,
+    val company: String,
+    val skills: MutableList<Skill>,
+    val languages: MutableList<Language>
+)

src/main/kotlin/study/person/PersonBuilder.kt

@@ -0,0 +1,34 @@
+package study.person
+
+import study.language.Language
+import study.language.LanguageBuilder
+import study.skill.Skill
+import study.skill.SkillBuilder
+
+class PersonBuilder {
+
+    lateinit var name: String
+    lateinit var company: String
+    lateinit var skills: MutableList<Skill>
+    lateinit var languages: MutableList<Language>
+
+    fun name(value: String) {
+        name = value
+    }
+
+    fun company(value: String) {
+        company = value
+    }
+
+    fun skills(builder: SkillBuilder.() -> Unit) {
+        skills = SkillBuilder().apply(builder).build()
+    }
+
+    fun languages(builder: LanguageBuilder.() -> Unit) {
+        languages = LanguageBuilder().apply(builder).build()
+    }
+
+    fun build(): Person {
+        return Person(name, company, skills, languages)
+    }
+}

src/main/kotlin/study/skill/Skill.kt

@@ -0,0 +1,7 @@
+package study.skill
+
+sealed class Skill
+
+data class SoftSkill(val value: String) : Skill()
+
+data class HardSkill(val value: String) : Skill()

src/main/kotlin/study/skill/SkillBuilder.kt

@@ -0,0 +1,18 @@
+package study.skill
+
+class SkillBuilder {
+
+    var skills: MutableList<Skill> = mutableListOf()
+
+    fun soft(value: String) {
+        skills.add(SoftSkill(value))
+    }
+
+    fun hard(value: String) {
+        skills.add(HardSkill(value))
+    }
+
+    fun build(): MutableList<Skill> {
+        return skills
+    }
+}

src/main/kotlin/wordle/Application.kt

@@ -0,0 +1,35 @@
+package wordle
+
+import wordle.domain.Game
+import wordle.domain.GameResult
+import wordle.domain.Word
+import wordle.domain.Words
+import wordle.domain.WordsReader
+import wordle.view.InputView
+import wordle.view.OutputView
+import java.time.LocalDate
+
+fun main() {
+
+    val wordsReader = WordsReader("words.txt")
+    val words = Words(wordsReader.words)
+    val game = Game(words, LocalDate.now())
+    val gameResult = GameResult(game.maxRound)
+
+    OutputView.printInitMessage(game.maxRound)
+    play(game, gameResult)
+}
+
+private fun play(game: Game, gameResult: GameResult) {
+    return try {
+        while (!game.isOver) {
+            val playerWord = Word(InputView.requestAnswer())
+            val matchResult = game.matchResult(playerWord)
+            gameResult.add(matchResult)
+            OutputView.printGameResult(game.isOver, game.count, game.maxRound, gameResult)
+        }
+    } catch (exception: IllegalArgumentException) {
+        OutputView.printErrorMessage(exception.message)
+        play(game, gameResult)
+    }
+}

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

@@ -0,0 +1,46 @@
+package wordle.domain
+
+import java.time.LocalDate
+
+class Game(val words: Words, val date: LocalDate) {
+
+    var count: Int = 0
+        private set
+    var isOver: Boolean = false
+        private set
+    val maxRound: Int
+        get() = MAX_ROUND
+
+    fun matchResult(playerWord: Word): Tiles {
+        require(words.contains(playerWord)) { "[ERROR] words.txt에 있는 단어를 입력해주세요." }
+        val answer = words.findAnswer(date)
+        val tiles = playerWord.value.withIndex()
+            .mapIndexedNotNull { index, value ->
+                matchSpell(value.value, index, answer)
+            }
+        count++
+        val newTiles = Tiles(tiles)
+        updateIsOver(newTiles)
+        return newTiles
+    }
+
+    private fun updateIsOver(newTiles: Tiles) {
+        if (count >= MAX_ROUND || newTiles.isAllGreen()) {
+            isOver = true
+        }
+    }
+
+    private fun matchSpell(spell: Char, index: Int, answer: Word): Tile {
+        if (answer.sameIndexAndSpell(index, spell)) {
+            return Tile.GREEN
+        }
+        if (answer.contains(spell)) {
+            return Tile.YELLOW
+        }
+        return Tile.GRAY
+    }
+
+    companion object {
+        private const val MAX_ROUND = 6
+    }
+}

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

@@ -0,0 +1,11 @@
+package wordle.domain
+
+class GameResult(size: Int) {
+
+    var gameResult: MutableList<Tiles> = ArrayList(size)
+        private set
+
+    fun add(tiles: Tiles) {
+        this.gameResult.add(tiles)
+    }
+}

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

@@ -0,0 +1,12 @@
+package wordle.domain
+
+enum class Tile(val symbol: String) {
+
+    GRAY("⬜"),
+    GREEN("\uD83D\uDFE9"),
+    YELLOW("\uD83D\uDFE8");
+
+    fun isGreen(): Boolean {
+        return this == GREEN
+    }
+}

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

@@ -0,0 +1,8 @@
+package wordle.domain
+
+data class Tiles(val tiles: List<Tile>) {
+
+    fun isAllGreen(): Boolean {
+        return tiles.all { it.isGreen() }
+    }
+}

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

@@ -0,0 +1,23 @@
+package wordle.domain
+
+import java.util.regex.Pattern
+
+data class Word(val value: String) {
+
+    init {
+        require(isRightSize()) { "[ERROR] 5글자의 단어를 입력하세요." }
+        require(isAlphabet()) { "[ERROR] 영어 단어를 입력하세요." }
+    }
+
+    private fun isRightSize(): Boolean = value.length == SIZE
+
+    private fun isAlphabet(): Boolean = Pattern.matches("^[a-zA-Z]*$", value)
+
+    fun sameIndexAndSpell(index: Int, spell: Char): Boolean = value[index] == spell
+
+    fun contains(spell: Char): Boolean = value.contains(spell)
+
+    companion object {
+        private const val SIZE = 5
+    }
+}

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

@@ -0,0 +1,20 @@
+package wordle.domain
+
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+class Words(private val words: List<Word>) {
+
+    fun findAnswer(current: LocalDate): Word {
+        val answerIndex = ChronoUnit.DAYS.between(BASE_DATE, current)
+        return words[answerIndex.toInt() % words.size]
+    }
+
+    fun contains(word: Word): Boolean {
+        return words.contains(word)
+    }
+
+    companion object {
+        private val BASE_DATE = LocalDate.of(2021, 6, 19)
+    }
+}

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

@@ -0,0 +1,16 @@
+package wordle.domain
+
+import java.io.File
+
+class WordsReader(private val path: String) {
+
+    val words: List<Word>
+        get() = getWords(path)
+
+    companion object {
+        private fun getWords(path: String): List<Word> {
+            return File(ClassLoader.getSystemResource(path).file).readLines()
+                .map { Word(it) }
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+package wordle.view
+
+object InputView {
+
+    fun requestAnswer(): String {
+        println()
+        println("정답을 입력해 주세요.")
+        return readln()
+    }
+}

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

@@ -0,0 +1,33 @@
+package wordle.view
+
+import wordle.domain.GameResult
+import wordle.domain.Tiles
+
+object OutputView {
+
+    fun printInitMessage(maxRound: Int) {
+        println("WORDLE을 ${maxRound}번 만에 맞춰 보세요.")
+        println("시도의 결과는 타일의 색 변화로 나타납니다.")
+    }
+
+    fun printGameResult(isOver: Boolean, count: Int, maxRound: Int, gameResult: GameResult) {
+        if (isOver) {
+            println("$count/$maxRound")
+        }
+        println()
+        gameResult.gameResult
+            .forEach {
+                printTiles(it)
+                println()
+            }
+    }
+
+    private fun printTiles(tiles: Tiles) {
+        tiles.tiles
+            .forEach { print(it.symbol) }
+    }
+
+    fun printErrorMessage(message: String?) {
+        println(message)
+    }
+}

src/test/kotlin/study/Introduce.kt

@@ -0,0 +1,40 @@
+package study
+
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import study.language.Language
+import study.skill.HardSkill
+import study.skill.SoftSkill
+
+class Introduce {
+
+    @Test
+    fun `자기소개`() {
+        val person = introduce {
+            name("제로")
+            company("우아한테크코스")
+            skills {
+                soft("A passion for problem solving")
+                soft("common communication skills")
+                hard("Kotlin")
+            }
+            languages {
+                "Korean" level 2
+                "English" level 1
+            }
+        }
+
+        person.name shouldBe "제로"
+        person.company shouldBe "우아한테크코스"
+        person.skills shouldContainExactly listOf(
+            SoftSkill("A passion for problem solving"),
+            SoftSkill("common communication skills"),
+            HardSkill("Kotlin")
+        )
+        person.languages shouldContainExactly listOf(
+            Language("Korean", 2),
+            Language("English", 1)
+        )
+    }
+}