Second submission for challenge

.gitignore

@@ -3,4 +3,5 @@ HTW/.idea
 HTW/.idea/workspace.xml
 HTW/.DS_Store
 
+fitnesse/FitNesseRoot/**/*.zip
 

HTW/src/htw/HuntTheWumpus.java

@@ -1,9 +1,7 @@
 package htw;
 
-import htw.game.HuntTheWumpusGame;
-
 public interface HuntTheWumpus {
-  public enum Direction {
+  enum Direction {
     NORTH {
       public Direction opposite() {
         return SOUTH;
@@ -39,11 +37,11 @@ public Direction opposite() {
   Integer getArrowsInCavern(String cavern);
   void connectCavern(String from, String to, Direction direction);
   String findDestination(String cavern, Direction direction);
-  HuntTheWumpusGame.Command makeRestCommand();
-  HuntTheWumpusGame.Command makeShootCommand(Direction direction);
-  HuntTheWumpusGame.Command makeMoveCommand(Direction direction);
+  Command makeRestCommand();
+  Command makeShootCommand(Direction direction);
+  Command makeMoveCommand(Direction direction);
 
-  public interface Command {
+  interface Command {
     void execute();
   }
 }

HTW/src/htw/console/Main.java

@@ -71,7 +71,7 @@ public class Main implements HtwMessageReceiver {
   };
 
   public static void main(String[] args) throws IOException {
-    game = HtwFactory.makeGame("htw.game.HuntTheWumpusGame", new Main());
+    game = HtwFactory.makeGame("htw.game.HuntTheWumpusFacade", new Main());
     createMap();
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     game.makeRestCommand().execute();
@@ -107,8 +107,8 @@ else if (command.equalsIgnoreCase("q"))
   }
 
   private static void createMap() {
-    int ncaverns = (int) (Math.random() * 30.0 + 10.0);
-    while (ncaverns-- > 0)
+    int nCaverns = (int) (Math.random() * 30.0 + 10.0);
+    while (nCaverns-- > 0)
       caverns.add(makeName());
 
     for (String cavern : caverns) {
@@ -153,7 +153,7 @@ private static void maybeConnectCavern(String cavern, Direction direction) {
   }
 
   private static void connectIfAvailable(String from, Direction direction, String to) {
-    if (game.findDestination(from, direction) == null) {
+    if (game.findDestination(from, direction).isEmpty()) {
       game.connectCavern(from, to, direction);
     }
   }

HTW/src/htw/game/Cavern.java

@@ -0,0 +1,76 @@
+package htw.game;
+
+import htw.HuntTheWumpus;
+
+import java.util.*;
+
+import static htw.HuntTheWumpus.*;
+
+class Cavern {
+  public static final Cavern NULL = new NullCavern();
+
+  private String name;
+  private Map<HuntTheWumpus.Direction, Cavern> connections = new HashMap<>();
+
+  public Cavern(String name) {
+    this.name = name;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public boolean isNamed(String name) {
+    return this.name.equals(name);
+  }
+
+  public Cavern findDestination(Direction direction) {
+    Cavern destination = connections.get(direction);
+    return (destination != null) ? destination : new NullCavern();
+  }
+
+  public Set<HuntTheWumpus.Direction> availableDirections() {
+    return connections.keySet();
+  }
+
+  public List<Cavern> connectedCaverns() {
+    return new ArrayList<>(connections.values());
+  }
+
+  public void addConnection(Cavern to, Direction direction) {
+    connections.put(direction, to);
+  }
+
+  public List<Cavern> getCavernsGoing(Direction direction) {
+    List<Cavern> caverns = new ArrayList<>();
+    return findDestination(direction).accumulateCavernsGoing(direction, caverns, this);
+  }
+
+  protected List<Cavern> accumulateCavernsGoing(Direction direction, List<Cavern> caverns, Cavern initialCavern) {
+    caverns.add(this);
+    if (initialCavern.equals(this))
+      return caverns;
+
+    return findDestination(direction).accumulateCavernsGoing(direction, caverns, initialCavern);
+  }
+
+  public boolean isNull() {
+    return false;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof Cavern) {
+      Cavern c = (Cavern) obj;
+      return getName().equals(c.getName());
+    }
+
+    return false;
+  }
+
+  @Override
+  public int hashCode() {
+    return getName().hashCode();
+  }
+}
+

HTW/src/htw/game/Game.java

@@ -0,0 +1,161 @@
+package htw.game;
+
+import java.util.*;
+import java.util.function.Predicate;
+
+import static htw.HuntTheWumpus.Direction;
+
+public class Game {
+  private Set<Cavern> caverns = new HashSet<>();
+  private Set<Cavern> pitCaverns = new HashSet<>();
+  private Set<Cavern> batCaverns = new HashSet<>();
+
+  private Cavern playerCavern = Cavern.NULL;
+  private Cavern wumpusCavern = Cavern.NULL;
+  private int quiver = 0;
+
+  private Map<Cavern, Integer> arrowsIn = new HashMap<>();
+  private RandomChooser randomChooser = new RandomChooser();
+
+  public Cavern getCavernNamed(String cavernName) {
+    return caverns.stream()
+        .filter(c -> c.isNamed(cavernName))
+        .findAny()
+        .orElse(new Cavern(cavernName));
+  }
+
+  public void connectCavern(Cavern from, Cavern to, Direction direction) {
+    from.addConnection(to, direction);
+    caverns.add(from);
+    caverns.add(to);
+  }
+
+  public Set<Direction> availableDirections() {
+    return playerCavern.availableDirections();
+  }
+
+  public void addBatCavern(Cavern cavern) {
+    batCaverns.add(cavern);
+  }
+
+  public void addPitCavern(Cavern cavern) {
+    pitCaverns.add(cavern);
+  }
+
+  public Cavern getWumpusCavern() {
+    return wumpusCavern;
+  }
+
+  public void setWumpusCavern(Cavern cavern) {
+    wumpusCavern = cavern;
+  }
+
+  public Cavern getPlayerCavern() {
+    return playerCavern;
+  }
+
+  public void setPlayerCavern(Cavern cavern) {
+    playerCavern = cavern;
+  }
+
+  public boolean playerIsInPitCavern() {
+    return pitCaverns.contains(playerCavern);
+  }
+
+  public boolean playerIsInBatsCavern() {
+    return batCaverns.contains(playerCavern);
+  }
+
+  public boolean playerIsInWumpusCavern() {
+    return playerCavern.equals(wumpusCavern);
+  }
+
+  public boolean wumpusCavernIsNear() {
+    return reportNearby(wumpusCavern::equals);
+  }
+
+  public boolean pitCavernIsNear() {
+    return reportNearby(pitCaverns::contains);
+  }
+
+  public boolean batCavernIsNear() {
+    return reportNearby(batCaverns::contains);
+  }
+
+  private boolean reportNearby(Predicate<Cavern> nearTest) {
+    return playerCavern.connectedCaverns().stream()
+        .anyMatch(nearTest::test);
+  }
+
+  public void randomlyTransportPlayer() {
+    List<Cavern> transportChoices = new ArrayList<>(caverns);
+    transportChoices.remove(playerCavern);
+
+    playerCavern = randomChooser.chooseFrom(transportChoices);
+  }
+
+  public void moveWumpus() {
+    List<Cavern> wumpusChoices = wumpusCavern.connectedCaverns();
+    wumpusChoices.add(wumpusCavern);
+
+    wumpusCavern = randomChooser.chooseFrom(wumpusChoices);
+  }
+
+  public Cavern getPlayerDestinationGoing(Direction direction) {
+    return playerCavern.findDestination(direction);
+  }
+
+  public void incrementArrowsIn(Cavern arrowCavern, int numberOfArrows) {
+    int arrows = getArrowsInCavern(arrowCavern);
+    arrowsIn.put(arrowCavern, arrows + numberOfArrows);
+  }
+
+  public void clearArrowsInPlayerCavern() {
+    arrowsIn.put(playerCavern, 0);
+  }
+
+  public int getArrowsInPlayerCavern() {
+    return getArrowsInCavern(playerCavern);
+  }
+
+  public Integer getArrowsInCavern(Cavern cavern) {
+    return zeroIfNull(arrowsIn.get(cavern));
+  }
+
+  private int zeroIfNull(Integer integer) {
+    if (integer == null)
+      return 0;
+    else
+      return integer;
+  }
+
+  public void clearMap() {
+    playerCavern = Cavern.NULL;
+    wumpusCavern = Cavern.NULL;
+
+    batCaverns.clear();
+    pitCaverns.clear();
+    arrowsIn.clear();
+    caverns.clear();
+  }
+
+  public int getQuiver() {
+    return quiver;
+  }
+
+  void setQuiver(int arrows) {
+    this.quiver = arrows;
+  }
+
+  public void decrementQuiverBy(int arrowNumber) {
+    quiver -= arrowNumber;
+  }
+
+  public void incrementQuiverBy(int arrowNumber) {
+    quiver += arrowNumber;
+  }
+
+  public boolean quiverEmpty() {
+    return quiver == 0;
+  }
+}

HTW/src/htw/game/GameCommand.java

@@ -0,0 +1,45 @@
+package htw.game;
+
+import htw.HtwMessageReceiver;
+import htw.HuntTheWumpus;
+
+abstract class GameCommand implements HuntTheWumpus.Command {
+  protected Game game;
+  protected HtwMessageReceiver messageReceiver;
+
+  public GameCommand(Game game, HtwMessageReceiver messageReceiver) {
+    this.game = game;
+    this.messageReceiver = messageReceiver;
+  }
+
+  public void execute() {
+    processCommand();
+
+    game.moveWumpus();
+
+    reportStatus();
+  }
+
+  protected abstract void processCommand();
+
+  private void reportStatus() {
+    reportAvailableDirections();
+    reportSpecialLocations();
+  }
+
+  private void reportAvailableDirections() {
+    game.availableDirections().forEach(messageReceiver::passage);
+  }
+
+  private void reportSpecialLocations() {
+    if (game.playerIsInWumpusCavern())
+      messageReceiver.wumpusMovesToPlayer();
+    if (game.batCavernIsNear())
+      messageReceiver.hearBats();
+    if (game.pitCavernIsNear())
+      messageReceiver.hearPit();
+    if (game.wumpusCavernIsNear())
+      messageReceiver.smellWumpus();
+  }
+
+}