Refactor 2 by char16t

src/main/java/hangman/AbstractGame.java

@@ -0,0 +1,52 @@
+package hangman;
+
+import java.io.PrintStream;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * Hangman game.
+ */
+public interface AbstractGame {
+    /**
+     * The hidden word.
+     *
+     * @return The hidden word
+     */
+    AbstractWord word();
+
+    /**
+     * Maximum number of mistakes.
+     *
+     * @return Maximum number of mistakes
+     */
+    Integer mistakes();
+
+    /**
+     * Input stream scanner.
+     *
+     * @return Input stream scanner
+     */
+    Scanner input();
+
+    /**
+     * Output stream.
+     *
+     * @return Output stream
+     */
+    PrintStream output();
+
+    /**
+     * Attempts to guess the word.
+     *
+     * @return List of guesses
+     */
+    List<AbstractGuess> guesses();
+
+    /**
+     * Run game.
+     *
+     * @throws Exception When something is wrong
+     */
+    void run() throws Exception;
+}

src/main/java/hangman/AbstractGuess.java

@@ -0,0 +1,28 @@
+package hangman;
+
+/**
+ * AbstractGuess.
+ */
+public interface AbstractGuess {
+    /**
+     * AbstractWord.
+     *
+     * @return AbstractWord
+     */
+    AbstractWord word();
+
+    /**
+     * Letter in the word.
+     *
+     * @return Letter in the word
+     */
+    Character character();
+
+    /**
+     * Is letter guessed?
+     *
+     * @return true if the guessed letter
+     * @throws Exception When something is wrong
+     */
+    boolean guessed() throws Exception;
+}

src/main/java/hangman/AbstractRandomWord.java

@@ -0,0 +1,20 @@
+package hangman;
+
+/**
+ * Random word.
+ */
+public interface AbstractRandomWord {
+    /**
+     * Available words.
+     *
+     * @return Available words
+     */
+    AbstractWord[] words();
+
+    /**
+     * Choose one of available words.
+     *
+     * @throws Exception When something is wrong
+     */
+    AbstractWord random() throws Exception;
+}

src/main/java/hangman/AbstractStringsAsWords.java

@@ -0,0 +1,20 @@
+package hangman;
+
+/**
+ * Strings as words.
+ */
+public interface AbstractStringsAsWords {
+    /**
+     * Original strings.
+     *
+     * @return Original strings
+     */
+    String[] strings();
+
+    /**
+     * Convert original strings to words.
+     *
+     * @return Original strings as words
+     */
+    AbstractWord[] toWords();
+}

src/main/java/hangman/AbstractWord.java

@@ -0,0 +1,59 @@
+package hangman;
+
+/**
+ * AbstractWord.
+ */
+public interface AbstractWord {
+    /**
+     * Original word.
+     *
+     * @return Original word
+     */
+    String original();
+
+    /**
+     * Mask symbol that displayed instead of unguessed letters
+     *
+     * @return Mask symbol
+     */
+    Character symbol();
+
+    /**
+     * The word with replaced unguessed letters to mask symbol.
+     *
+     * @return Masked word
+     */
+    String word();
+
+    /**
+     * Check that word contains letter.
+     *
+     * @param character Letter
+     * @return True if word contains letter
+     * @throws Exception When something is wrong
+     */
+    boolean contains(Character character) throws Exception;
+
+    /**
+     * Check that word is guessed
+     * @return true if all letters of word is guessed
+     * @throws Exception When something is wrong
+     */
+    boolean guessed() throws Exception;
+
+    /**
+     * Open letter by value.
+     *
+     * @param character Letter
+     * @throws Exception When something is wrong
+     */
+    void open(Character character) throws Exception;
+
+    /**
+     * Check that letter is opened.
+     *
+     * @param character Letter
+     * @return tue if letter is opened
+     */
+    boolean opened(Character character);
+}

src/main/java/hangman/Application.java

@@ -0,0 +1,34 @@
+package hangman;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public final class Application {
+
+    private final InputStream input;
+    private final OutputStream output;
+    private final Integer mistakes;
+
+    public Application(final InputStream input, final OutputStream output, final Integer mistakes) {
+        this.input = input;
+        this.output = output;
+        this.mistakes = mistakes;
+    }
+
+    public static void main(final String[] args) throws Exception {
+        new Application(System.in, System.out, 5).execute();
+    }
+
+    public void execute() throws Exception {
+        new Game(
+                new RandomWord(
+                        "simplicity", "equality", "grandmother",
+                        "neighborhood", "relationship", "mathematics",
+                        "university", "explanation"
+                ).random(),
+                this.mistakes,
+                this.input,
+                this.output
+        ).run();
+    }
+}

src/main/java/hangman/Game.java

@@ -0,0 +1,74 @@
+package hangman;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Scanner;
+
+public final class Game implements AbstractGame {
+
+    private final AbstractWord word;
+    private final Integer mistakes;
+    private final Scanner input;
+    private final PrintStream output;
+    private final List<AbstractGuess> guesses;
+
+    public Game(final AbstractWord word, final Integer mistakes, final InputStream input, final OutputStream output) {
+        this(word, mistakes, input, new PrintStream(output), new LinkedList<AbstractGuess>());
+    }
+
+    public Game(final AbstractWord word, final Integer mistakes, final InputStream input, final OutputStream output, final List<AbstractGuess> guesses) {
+        this(word, mistakes, new Scanner(input), new PrintStream(output), guesses);
+    }
+
+    public Game(final AbstractWord word, final Integer mistakes, final Scanner input, final PrintStream output, final List<AbstractGuess> guesses) {
+        this.word = word;
+        this.mistakes = mistakes;
+        this.input = input;
+        this.output = output;
+        this.guesses = guesses;
+    }
+
+    public AbstractWord word() {
+        return this.word;
+    }
+
+    public Integer mistakes() {
+        return this.mistakes;
+    }
+
+    public Scanner input() {
+        return this.input;
+    }
+
+    public PrintStream output() {
+        return this.output;
+    }
+
+    public List<AbstractGuess> guesses() {
+        return this.guesses;
+    }
+
+    public void run() throws Exception {
+        while (this.guesses.size() < this.mistakes && !this.word.guessed()) {
+            this.output.print("AbstractGuess a letter: ");
+            final AbstractGuess guess = new Guess(this.word, this.input.next().charAt(0));
+            if (guess.guessed()) {
+                this.word.open(guess.character());
+                this.output.println("Hit!");
+            } else {
+                this.guesses.add(guess);
+                this.output.printf("Missed, mistake #%d out of %d\n", this.guesses.size(), this.mistakes);
+            }
+            this.output.println(this.word.word());
+        }
+        if (this.word.guessed()) {
+            this.output.println("You won!");
+        } else {
+            this.output.println("You lost.");
+        }
+        this.output.append("The word: " + this.word.original());
+    }
+}

src/main/java/hangman/Guess.java

@@ -0,0 +1,24 @@
+package hangman;
+
+public final class Guess implements AbstractGuess {
+
+    private final AbstractWord word;
+    private final Character character;
+
+    public Guess(final AbstractWord word, final Character character) {
+        this.word = word;
+        this.character = character;
+    }
+
+    public AbstractWord word() {
+        return this.word;
+    }
+
+    public Character character() {
+        return this.character;
+    }
+
+    public boolean guessed() throws Exception {
+        return this.word.contains(this.character) && !this.word.opened(this.character());
+    }
+}