Autonomy and Messaging

src/main/java/common/Media.java

@@ -0,0 +1,6 @@
+package common;
+
+public interface Media
+{
+    void print(String text);
+}

src/main/java/common/Messages.java

@@ -0,0 +1,21 @@
+package common;
+
+import java.util.*;
+
+public final class Messages
+{
+    private final Map<String, Set<Recipient>> _recipients = new HashMap<>();
+
+    public void subcribeTo(String subject, Recipient recipient)
+    {
+        if (!_recipients.containsKey(subject))
+            _recipients.put(subject, new HashSet<>());
+        _recipients.get(subject).add(recipient);
+    }
+
+    public void send(String subject, String content)
+    {
+        if (_recipients.containsKey(subject))
+            _recipients.get(subject).forEach(x -> x.receive(content));
+    }
+}

src/main/java/common/PrintStreamMedia.java

@@ -0,0 +1,25 @@
+package common;
+
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+public final class PrintStreamMedia implements Media
+{
+    private final PrintStream _stream;
+
+    public PrintStreamMedia(OutputStream out)
+    {
+        this(new PrintStream(out));
+    }
+
+    public PrintStreamMedia(PrintStream stream)
+    {
+        _stream = stream;
+    }
+
+    @Override
+    public void print(String text)
+    {
+        _stream.print(text);
+    }
+}

src/main/java/common/Recipient.java

@@ -0,0 +1,6 @@
+package common;
+
+public interface Recipient
+{
+    void receive(String content);
+}

src/main/java/hangman/Gallows.java

@@ -0,0 +1,40 @@
+package hangman;
+
+import common.Messages;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class Gallows implements Runnable
+{
+    private final Messages _messages;
+
+    private AtomicInteger _mistakes;
+    private MistakeMax _max;
+
+    public Gallows(Messages messages, MistakeMax max)
+    {
+        _messages = messages;
+        _mistakes = new AtomicInteger();
+        _max = max;
+    }
+
+    @Override
+    public void run()
+    {
+        _messages.subcribeTo("GuessedCorrectly", x -> guessed(x));
+    }
+
+    private void guessed(String correctly)
+    {
+        if(!correctly.equals("true"))
+            _messages.send("GallowsUpdated", String.format("Mistakes: #%d out of %d\n",
+                _mistakes.incrementAndGet(), _max.intValue()));
+        checkForGameEnd();
+    }
+
+    private void checkForGameEnd()
+    {
+        if (_mistakes.get() == _max.intValue())
+            _messages.send("GameEnded", "lost");
+    }
+}

src/main/java/hangman/Game.java

@@ -0,0 +1,48 @@
+package hangman;
+
+import common.Media;
+import common.Messages;
+import common.PrintStreamMedia;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public final class Game implements Runnable
+{
+    private final List<Runnable> _objects;
+    private final WordList _words;
+    private final Messages _messages;
+
+    public static void main(String[] args)
+    {
+        new Game(System.in, System.out, new MistakeMax(5)).run();
+    }
+
+    public Game(InputStream in, OutputStream out, MistakeMax max)
+    {
+        this(new Messages(), new WordList(), new PrintStreamMedia(out), new Scanner(in), max);
+    }
+
+    public Game(Messages messages, WordList words, Media media, Scanner in, MistakeMax max)
+    {
+        this(messages, words, new UserInterface(messages, media, in), new Secret(messages),
+                new Gallows(messages, max));
+    }
+
+    private Game(Messages messages, WordList words, Runnable... objects)
+    {
+        _objects = Arrays.asList(objects);
+        _messages = messages;
+        _words = words;
+    }
+
+    @Override
+    public void run()
+    {
+        _objects.forEach(x -> x.run());
+        _messages.send("GameStarted", _words.random());
+    }
+}

src/main/java/hangman/MistakeMax.java

@@ -0,0 +1,16 @@
+package hangman;
+
+public final class MistakeMax
+{
+    private final int _max;
+
+    public MistakeMax(int max)
+    {
+        _max = max;
+    }
+
+    public int intValue()
+    {
+        return _max;
+    }
+}

src/main/java/hangman/Secret.java

@@ -0,0 +1,68 @@
+package hangman;
+
+import common.Messages;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public final class Secret implements Runnable
+{
+    private final Messages _messages;
+
+    private String _word;
+    private List<Boolean> _discovered;
+
+    public Secret(Messages messages)
+    {
+        _messages = messages;
+    }
+
+    @Override
+    public void run()
+    {
+        _messages.subcribeTo("GameStarted", x -> startGame(x));
+        _messages.subcribeTo("Guessed", x -> guess(x));
+    }
+
+    private void startGame(String result)
+    {
+        _word = result;
+        _discovered = _word.chars().mapToObj(x -> false).collect(Collectors.toList());
+        _messages.send("WordUpdated", publicWord());
+        _messages.send("GameSetup", "true");
+    }
+
+    private void guess(String guess)
+    {
+        String result = guessedCorrectly(guess);
+        _messages.send("WordUpdated", publicWord());
+        _messages.send("GuessedCorrectly", result);
+        checkForGameEnd();
+    }
+
+    private void checkForGameEnd()
+    {
+        if (_discovered.stream().allMatch(x -> x))
+            _messages.send("GameEnded", "won");
+    }
+
+    private String publicWord()
+    {
+        return String.join("", IntStream.range(0, _word.length())
+            .mapToObj(i -> _discovered.get(i) ? _word.substring(i, i + 1) : "?")
+            .collect(Collectors.toList())) + "\n";
+    }
+
+    private String guessedCorrectly(String guess)
+    {
+        String result = "false";
+        for (int i = 0; i < _word.length(); ++i) {
+            if (_word.charAt(i) == guess.charAt(0) && !_discovered.get(i)) {
+                _discovered.set(i, true);
+                result = "true";
+            }
+        }
+        return result;
+    }
+}