feat: first init

.gitignore

@@ -0,0 +1,46 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+.kotlin
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
+
+### IntelliJ ###
+.idea/

build.gradle

@@ -0,0 +1,35 @@
+plugins {
+    id 'java'
+    id 'application'
+}
+
+group = project.maven_group
+version = project.version
+
+application {
+    mainClass = "dev.darwincereska.terminordle.App"
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(project.java_version as int)
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+
+}
+
+tasks.withType(JavaCompile).configureEach {
+    options.release = java_version as int
+}
+
+jar {
+    manifest {
+        attributes 'Main-Class': application.mainClass.get()
+    }
+}

gradle.properties

@@ -0,0 +1,9 @@
+maven_group=dev.darwincereska
+version=0.1.0
+
+java_version=17
+
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+org.gradle.daemon=true
+org.gradle.parallel=true

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Thu May 14 20:52:57 EDT 2026
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'terminordle'

src/main/java/dev/darwincereska/terminordle/App.java

@@ -0,0 +1,70 @@
+package dev.darwincereska.terminordle;
+
+import dev.darwincereska.terminordle.color.Color;
+import dev.darwincereska.terminordle.game.Game;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.Scanner;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class App {
+    private static Set<String> downloadWords() throws Exception {
+        String url = "https://gist.githubusercontent.com/dracos/dd0668f281e685bad51479e5acaadb93/raw/6bfa15d263d6d5b63840a8e5b64e04b382fdb079/valid-wordle-words.txt";
+        HttpClient client = HttpClient.newHttpClient();
+
+        // Create the request
+        HttpRequest request = HttpRequest.newBuilder(URI.create(url)).build();
+
+        // Download the data
+        HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
+
+        // Create the set
+        Set<String> words;
+
+        // Parse data
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.body()))) {
+            words = reader.lines().collect(Collectors.toSet());
+        }
+
+        // Return set
+        return words;
+    }
+
+    public static void main(String[] args) {
+        Set<String> wordSet;
+
+        // Download words
+        try {
+            wordSet = downloadWords();
+        } catch (Exception e) {
+            e.printStackTrace(System.err);
+            System.exit(1);
+            return;
+        }
+
+        Game game = new Game(wordSet);
+        Scanner scanner = new Scanner(System.in);
+
+        // Game loop
+        while (!game.hasWon && game.getRow() < 6) {
+            // Print screen
+            game.clearScreen();
+            game.board.print();
+
+            // Get users guess
+            System.out.print("Enter guess: ");
+            String input = scanner.nextLine();
+            game.guess(input);
+        }
+
+        game.clearScreen();
+        game.board.print();
+        if (!game.hasWon) System.out.println("Word was: " + Color.wrap(game.getWord(), "green", null, true));
+    }
+}

src/main/java/dev/darwincereska/terminordle/color/Color.java

@@ -0,0 +1,145 @@
+package dev.darwincereska.terminordle.color;
+
+import java.io.Console;
+import java.util.Locale;
+
+public final class Color {
+    public static final String RESET = "\u001b[0m";
+    public static final String BOLD = "\u001b[1m";
+
+    // Foreground
+    public static final String BLACK = "\u001b[30m";
+    public static final String RED = "\u001b[31m";
+    public static final String GREEN = "\u001b[32m";
+    public static final String YELLOW = "\u001b[33m";
+    public static final String BLUE = "\u001b[34m";
+    public static final String MAGENTA = "\u001b[35m";
+    public static final String CYAN = "\u001b[36m";
+    public static final String WHITE = "\u001b[37m";
+
+    // Background
+    public static final String BG_BLACK = "\u001b[40m";
+    public static final String BG_RED = "\u001b[41m";
+    public static final String BG_GREEN = "\u001b[42m";
+    public static final String BG_YELLOW = "\u001b[43m";
+    public static final String BG_BLUE = "\u001b[44m";
+    public static final String BG_MAGENTA = "\u001b[45m";
+    public static final String BG_CYAN = "\u001b[46m";
+    public static final String BG_WHITE = "\u001b[47m";
+
+    private Color() {
+    }
+
+    public static String fg(String name) {
+        return switch (normalize(name)) {
+            case "black" -> BLACK;
+            case "red" -> RED;
+            case "green" -> GREEN;
+            case "yellow" -> YELLOW;
+            case "blue" -> BLUE;
+            case "magenta" -> MAGENTA;
+            case "cyan" -> CYAN;
+            case "white" -> WHITE;
+            default -> throw new IllegalArgumentException("Unknown foreground color: " + name);
+        };
+    }
+
+    public static String bg(String name) {
+        return switch (normalize(name)) {
+            case "black" -> BG_BLACK;
+            case "red" -> BG_RED;
+            case "green" -> BG_GREEN;
+            case "yellow" -> BG_YELLOW;
+            case "blue" -> BG_BLUE;
+            case "magenta" -> BG_MAGENTA;
+            case "cyan" -> BG_CYAN;
+            case "white" -> BG_WHITE;
+            default -> throw new IllegalArgumentException("Unknown background color: " + name);
+        };
+    }
+
+    public static String bold(String text) {
+        return BOLD + text + RESET;
+    }
+
+    public static String wrap(String text, String foreground) {
+        return wrap(text, foreground, null);
+    }
+
+    public static String wrap(String text, String foreground, String background) {
+        return wrap(text, foreground, background, false);
+    }
+
+    public static String wrap(String text, String foreground, String background, boolean bold) {
+        if (!supportsAnsi()) {
+            return text;
+        }
+
+        StringBuilder builder = new StringBuilder();
+        if (bold) {
+            builder.append(BOLD);
+        }
+        if (foreground != null && !foreground.isBlank()) {
+            builder.append(fg(foreground));
+        }
+        if (background != null && !background.isBlank()) {
+            builder.append(bg(background));
+        }
+        builder.append(text);
+        builder.append(RESET);
+        return builder.toString();
+    }
+
+    public static String tile(String text, String background) {
+        return tile(text, background, isBright(background) ? "black" : "white");
+    }
+
+    public static String tile(String text, String background, String foreground) {
+        return wrap(padCenter(text, 3), foreground, background, true);
+    }
+
+    private static boolean isBright(String background) {
+        if (background == null) {
+            return false;
+        }
+        return switch (normalize(background)) {
+            case "yellow", "white" -> true;
+            default -> false;
+        };
+    }
+
+    private static String padCenter(String text, int width) {
+        String value = text == null ? "" : text.trim();
+        if (value.length() >= width) {
+            return value.substring(0, width);
+        }
+
+        int totalPadding = width - value.length();
+        int left = totalPadding / 2;
+        int right = totalPadding - left;
+        return " ".repeat(left) + value + " ".repeat(right);
+    }
+
+    public static boolean supportsAnsi() {
+        String term = System.getenv("TERM");
+        String noColor = System.getenv("NO_COLOR");
+        Console console = System.console();
+
+        if (noColor != null) {
+            return false;
+        }
+
+        if (console == null) {
+            return false;
+        }
+
+        return term != null && !term.isBlank() && !term.equalsIgnoreCase("dumb");
+    }
+
+    private static String normalize(String value) {
+        if (value == null) {
+            throw new IllegalArgumentException("Color name cannot be null");
+        }
+        return value.trim().toLowerCase(Locale.ROOT);
+    }
+}

src/main/java/dev/darwincereska/terminordle/color/annotations/Background.java

@@ -0,0 +1,23 @@
+package dev.darwincereska.terminordle.color.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Apply a background ANSI color to a target. Value should be a color name
+ * supported by dev.darwincereska.terminordle.color.Color (e.g. "blue").
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({
+        ElementType.TYPE,
+        ElementType.METHOD,
+        ElementType.FIELD,
+        ElementType.PARAMETER,
+        ElementType.TYPE_USE,
+        ElementType.LOCAL_VARIABLE
+})
+public @interface Background {
+    String value();
+}

src/main/java/dev/darwincereska/terminordle/color/annotations/Color.java

@@ -0,0 +1,23 @@
+package dev.darwincereska.terminordle.color.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Apply a foreground ANSI color to a target. Value should be a color name
+ * supported by dev.darwincereska.terminordle.color.Color (e.g. "red").
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({
+        ElementType.TYPE,
+        ElementType.METHOD,
+        ElementType.FIELD,
+        ElementType.PARAMETER,
+        ElementType.TYPE_USE,
+        ElementType.LOCAL_VARIABLE
+})
+public @interface Color {
+    String value();
+}

src/main/java/dev/darwincereska/terminordle/game/Game.java

@@ -0,0 +1,190 @@
+package dev.darwincereska.terminordle.game;
+
+import dev.darwincereska.terminordle.color.Color;
+
+import java.util.*;
+
+public class Game {
+    private final String word;
+    private final Set<String> wordSet;
+    private int row = 0;
+    public boolean hasWon = false;
+    public Board board;
+    private final Random random = new Random();
+
+    // Create game
+    public Game(Set<String> wordSet) {
+        this.board = new Board();
+        this.wordSet = wordSet;
+        List<String> wordList = new ArrayList<>(wordSet);
+        this.word = normalize(wordList.get(random.nextInt(wordList.size())));
+    }
+
+    // Returns current row
+    public int getRow() {
+        return row;
+    }
+
+    // Returns the current word
+    public String getWord() {
+        return this.word;
+    }
+
+    // Game board
+    public class Board {
+        private static final int COLS = 5;
+        private static final int CELL_WIDTH = 3;
+        private static final int CELL_GAP = 1;
+        private static final int INNER_PADDING = 1;
+        private List<List<String>> board;
+
+        public Board() {
+            create();
+        }
+
+        // Creates an empty game board
+        private void create() {
+            this.board = new ArrayList<>();
+            for (int i = 0; i < 6; i++) {
+                this.board.add(new ArrayList<>(List.of(
+                    Color.tile(" ", "white", "black"),
+                    Color.tile(" ", "white", "black"),
+                    Color.tile(" ", "white", "black"),
+                    Color.tile(" ", "white", "black"),
+                    Color.tile(" ", "white", "black")
+                )));
+            }
+        }
+
+        // Prints the board
+        public void print() {
+           System.out.printf("┏%s┓\n", "━".repeat(innerWidth() + 2));
+           System.out.printf("┃%s┃\n", center(Color.wrap("TERMINORDLE", "green", null, true), innerWidth() + 2));
+           System.out.printf("┣%s┫\n", "━".repeat(innerWidth() + 2));
+            for (int rowIndex = 0; rowIndex < this.board.size(); rowIndex++) {
+                List<String> row = this.board.get(rowIndex);
+                System.out.print("┃ ");
+                for (int i = 0; i < row.size(); i++) {
+                    System.out.print(row.get(i));
+                    if (i < row.size() - 1) {
+                        System.out.print(" ");
+                    }
+                }
+                System.out.println(" ┃");
+                if (rowIndex < this.board.size() - 1) {
+                    System.out.printf("┃%s┃\n", " ".repeat(innerWidth() + 2));
+                }
+            }
+           System.out.printf("┗%s┛\n", "━".repeat(innerWidth() + 2));
+        }
+
+        private int innerWidth() {
+            return (COLS * CELL_WIDTH) + ((COLS - 1) * CELL_GAP);
+        }
+
+        private String center(String text, int width) {
+            String value = text == null ? "" : text;
+            int visible = value.replaceAll("\\u001b\\[[;\\d]*m", "").length();
+            if (visible >= width) {
+                return value;
+            }
+
+            int totalPadding = width - visible;
+            int left = totalPadding / 2;
+            int right = totalPadding - left;
+            return " ".repeat(left) + value + " ".repeat(right);
+        }
+
+        // Returns the current row
+        public List<String> get() {
+            return this.board.get(row);
+        }
+
+        // Sets the character at the index
+        public void set(int index, String value) {
+            if (!value.startsWith("\u001b")) {
+                value = normalize(value);
+            }
+            this.board.get(row).set(index, value);
+        }
+
+        // Resets the board
+        public void reset() {
+            create();
+        }
+    }
+
+    // Normalize a string
+    private String normalize(String word) {
+        return word.strip().toLowerCase();
+    }
+
+    // Clears the terminal
+    public void clearScreen() {
+        if (Color.supportsAnsi()) {
+            System.out.print("\033[H\033[2J");
+            System.out.flush();
+            return;
+        }
+
+        for (int i = 0; i < 40; i++) {
+            System.out.println();
+        }
+    }
+
+    // Guess a word
+    public void guess(String input) {
+        // Edge cases
+        if (input.length() != 5) return;
+        if (this.row > 5) return;
+        if (!wordSet.contains(normalize(input))) return;
+
+        // Normalize the input
+        input = normalize(input);
+
+        // Check if the input matches the word (skips unnecessary code)
+        if (input.equals(this.word)) {
+            this.hasWon = true;
+            // Set the board
+            for (int i = 0; i < input.length(); i++) this.board.set(i, Color.tile(String.valueOf(input.charAt(i)), "green"));
+            return;
+        }
+
+        // Store the remaining count for each letter in the answer
+        Map<Character, Integer> letterCounts = new HashMap<>();
+        for (int i = 0; i < this.word.length(); i++) {
+            char c = this.word.charAt(i);
+            letterCounts.put(c, letterCounts.getOrDefault(c, 0) + 1);
+        }
+
+        // First pass: mark greens and consume those letters
+        for (int i = 0; i < input.length(); i++) {
+            char letter = input.charAt(i);
+            if (letter == word.charAt(i)) {
+                this.board.set(i, Color.tile(String.valueOf(letter), "green"));
+                letterCounts.put(letter, letterCounts.get(letter) - 1);
+            }
+        }
+
+        // Second pass: mark yellows and grays
+        for (int i = 0; i < input.length(); i++) {
+            char letter = input.charAt(i);
+
+            // Skip correct letters
+            if (letter == word.charAt(i)) continue;
+
+            // Handle yellows
+            if (letterCounts.getOrDefault(letter, 0) > 0) {
+                this.board.set(i, Color.tile(String.valueOf(letter), "yellow"));
+                letterCounts.put(letter, letterCounts.get(letter) - 1);
+                continue;
+            }
+
+            // Handle grays
+            this.board.set(i, Color.tile(String.valueOf(letter), "white", "black"));
+        }
+
+        // Increment the row
+        this.row++;
+    }
+}