TODO tagging

8 files changed, 82 insertions, 52 deletions

diff --git a/dice-lang/src/bjc/dicelang/dice/DiceBox.java b/dice-lang/src/bjc/dicelang/dice/DiceBox.java
index f7bf719..8d00d96 100644
--- a/dice-lang/src/bjc/dicelang/dice/DiceBox.java
+++ b/dice-lang/src/bjc/dicelang/dice/DiceBox.java
@@ -27,8 +27,11 @@ public class DiceBox {
 			/*
 			 * @TODO 10/08/17 Ben Culkin :DieErrors :ErrorRefactor
 			 * 	Use different types of exceptions to provide
-			 * 	better error messages. */
-			System.out.println("ERROR: Could not parse die expression (Cause: %s)\n", ex.getMessage);
+			 * 	better error messages. 
+			 */
+			String exMessage = ex.getMessage();
+
+			System.out.printf("ERROR: Could not parse die expression (Cause: %s)\n", exMessage);
 			ex.printStackTrace();
 
 			return null;
@@ -260,6 +263,10 @@ public class DiceBox {
 	 * @return Whether or not the string is a valid command.
 	 */
 	public static boolean isValidExpression(final String exp) {
+		/* @NOTE
+		 * 	Should this matcher/matches expression be abstracted in
+		 * 	some way?
+		 */
 		if (scalarDiePattern.matcher(exp).matches()) {
 			return true;
 		} else if (simpleDiePattern.matcher(exp).matches()) {
@@ -281,24 +288,23 @@ public class DiceBox {
 		}
 	}
 
-	/*
-	 * Derive a predicate from a compare point
-	 */
+	/* Derive a predicate from a compare point */
 	private static Predicate<Long> deriveCond(final String patt) {
 		final long num = Long.parseLong(patt.substring(1));
 
+		/* @NOTE
+		 * 	Should this be extended in some way, to provide other
+		 * 	operators?
+		 */
 		switch (patt.charAt(0)) {
 		case '<':
-			return (roll) -> roll < num;
-
+			return (roll) -> (roll < num);
 		case '=':
-			return (roll) -> roll == num;
-
+			return (roll) -> (roll == num);
 		case '>':
-			return (roll) -> roll > num;
-
+			return (roll) -> (roll > num);
 		default:
-			return (roll) -> false;
+			return (roll) -> (false);
 		}
 	}
 }
diff --git a/dice-lang/src/bjc/dicelang/dice/DieExpression.java b/dice-lang/src/bjc/dicelang/dice/DieExpression.java
index 71b7a68..b8faeda 100644
--- a/dice-lang/src/bjc/dicelang/dice/DieExpression.java
+++ b/dice-lang/src/bjc/dicelang/dice/DieExpression.java
@@ -2,24 +2,25 @@ package bjc.dicelang.dice;
 
 import java.util.Arrays;
 
+/*
+ * @NOTE
+ * 	I'm not a particularly large fan of sticking everything on this class
+ * 	and just documenting which fields are tied together in a non-obvious
+ * 	way. I think a class hierarchy might be better, but I am unsure of the
+ * 	details.
+ */
 /**
  * Represents either a die or a die list.
  *
  * @author Ben Culkin
  */
 public class DieExpression {
-	/**
-	 * Is this expression a list?
-	 */
+	/** Is this expression a list? */
 	public final boolean isList;
 
-	/**
-	 * The scalar value in this expression, if there is one.
-	 */
+	/** The scalar value in this expression, if there is one. */
 	public Die      scalar;
-	/**
-	 * The list value in this expression, if there is one.
-	 */
+	/** The list value in this expression, if there is one. */
 	public DieList  list;
 
 	/**
diff --git a/dice-lang/src/bjc/dicelang/dice/ExplodingDice.java b/dice-lang/src/bjc/dicelang/dice/ExplodingDice.java
index 6458f04..e891a1c 100644
--- a/dice-lang/src/bjc/dicelang/dice/ExplodingDice.java
+++ b/dice-lang/src/bjc/dicelang/dice/ExplodingDice.java
@@ -13,16 +13,13 @@ import java.util.function.Predicate;
  * @author Ben Culkin

  */

 public class ExplodingDice implements DieList {

-	/*

-	 * The source die to use.

-	 */

+	/* The source die to use. */

 	private final Die source;

 

-	/*

-	 * The conditions for exploding.

-	 */

+	/* The conditions for exploding. */

 	private final Predicate<Long>   explodeOn;

 	private final String            explodePattern;

+	/* Whether or not to apply a -1 penalty to explosions. */

 	private final boolean           explodePenetrates;

 

 	/**

@@ -90,6 +87,7 @@ public class ExplodingDice implements DieList {
 		long oldRes = res;

 

 		final List<Long> resList = new LinkedList<>();

+		resList.add(res);

 

 		while (explodeOn.test(oldRes)) {

 			oldRes = source.rollSingle();

@@ -101,25 +99,26 @@ public class ExplodingDice implements DieList {
 			resList.add(oldRes);

 		}

 

-		final long[] newRes = new long[resList.size() + 1];

-		newRes[0] = res;

+		final long resArr[] = new long[resList.size()];

 

-		int i = 1;

-

-		for (final long rll : resList) {

-			newRes[i] = rll;

-			i += 1;

+		int i = 0;

+		for(long rll : resList) {

+			resArr[i] = rll;

+			i        += 1;

 		}

 

-		return newRes;

+		return resArr;

 	}

 

 	@Override

 	public String toString() {

+		String penString    = explodePenetrates ? "p" : "";

+		String sourceString = source.toString();

+

 		if (explodePattern == null) {

-			return source + (explodePenetrates ? "p" : "") + "!";

+			return String.format("%s%s!<complex-pred>", sourceString, penString);

 		}

 

-		return source + (explodePenetrates ? "p" : "") + "!" + explodePattern;

+		return String.format("%s%s!%s", sourceString, penString, explodePattern);

 	}

 }

diff --git a/dice-lang/src/bjc/dicelang/dice/FudgeDie.java b/dice-lang/src/bjc/dicelang/dice/FudgeDie.java
index 9457b58..23951b2 100644
--- a/dice-lang/src/bjc/dicelang/dice/FudgeDie.java
+++ b/dice-lang/src/bjc/dicelang/dice/FudgeDie.java
@@ -7,6 +7,7 @@ package bjc.dicelang.dice;
  *
  */
 public class FudgeDie implements Die {
+	/* The number of dice to roll. */
 	private final Die numDice;
 
 	/**
@@ -59,6 +60,8 @@ public class FudgeDie implements Die {
 
 	@Override
 	public String toString() {
-		return numDice + "dF";
+		String dieString = numDice.toString();
+
+		return String.format("%sdF", dieString);
 	}
 }
diff --git a/dice-lang/src/bjc/dicelang/dice/MathDie.java b/dice-lang/src/bjc/dicelang/dice/MathDie.java
index 1984581..e4f2953 100644
--- a/dice-lang/src/bjc/dicelang/dice/MathDie.java
+++ b/dice-lang/src/bjc/dicelang/dice/MathDie.java
@@ -7,6 +7,12 @@ package bjc.dicelang.dice;
  *
  */
 public class MathDie implements Die {
+	/* 
+	 * @TODO 10/08/17 Ben Culkin :MathGeneralize
+	 * 	Why do we have the operator types hardcoded, instead of just
+	 * 	having a general thing for applying a binary operator to dice?
+	 * 	Fix this by changing it to the more general form.
+	 */
 	/**
 	 * The types of a math operator.
 	 *
@@ -14,17 +20,11 @@ public class MathDie implements Die {
 	 *
 	 */
 	public static enum MathOp {
-		/**
-		 * Add two dice.
-		 */
+		/** Add two dice. */
 		ADD,
-		/**
-		 * Subtract two dice.
-		 */
+		/** Subtract two dice. */
 		SUBTRACT,
-		/**
-		 * Multiply two dice.
-		 */
+		/** Multiply two dice. */
 		MULTIPLY;
 
 		@Override
@@ -118,4 +118,4 @@ public class MathDie implements Die {
 	public String toString() {
 		return left.toString() + " " + type.toString() + " " + right.toString();
 	}
-}
\ No newline at end of file
+}
diff --git a/dice-lang/src/bjc/dicelang/dice/ScalarDie.java b/dice-lang/src/bjc/dicelang/dice/ScalarDie.java
index e7b5afa..cbe9d3f 100644
--- a/dice-lang/src/bjc/dicelang/dice/ScalarDie.java
+++ b/dice-lang/src/bjc/dicelang/dice/ScalarDie.java
@@ -7,6 +7,7 @@ package bjc.dicelang.dice;
  *
  */
 public class ScalarDie implements Die {
+	/* The die value. */
 	private final long val;
 
 	/**
@@ -41,6 +42,6 @@ public class ScalarDie implements Die {
 
 	@Override
 	public String toString() {
-		return Long.toString(val);
+		return String.format("%d", val);
 	}
-}
\ No newline at end of file
+}
diff --git a/dice-lang/src/bjc/dicelang/dice/SimpleDie.java b/dice-lang/src/bjc/dicelang/dice/SimpleDie.java
index ee10070..6cae423 100644
--- a/dice-lang/src/bjc/dicelang/dice/SimpleDie.java
+++ b/dice-lang/src/bjc/dicelang/dice/SimpleDie.java
@@ -7,7 +7,17 @@ package bjc.dicelang.dice;
  *
  */
 public class SimpleDie implements Die {
+	/* The number of dice to roll. */
 	private final Die       numDice;
+	/* 
+	 * The size of each dice to roll.
+	 *
+	 * Rolled once per role, not once for each dice rolled.
+	 *
+	 * @NOTE
+	 * 	Would having some way to roll it once for each dice rolled be
+	 * 	useful in any sort of case?
+	 */
 	private final Die       diceSize;
 
 	/**
@@ -106,4 +116,4 @@ public class SimpleDie implements Die {
 	public String toString() {
 		return numDice + "d" + diceSize;
 	}
-}
\ No newline at end of file
+}
diff --git a/dice-lang/src/bjc/dicelang/dice/SimpleDieList.java b/dice-lang/src/bjc/dicelang/dice/SimpleDieList.java
index 4546238..8391054 100644
--- a/dice-lang/src/bjc/dicelang/dice/SimpleDieList.java
+++ b/dice-lang/src/bjc/dicelang/dice/SimpleDieList.java
@@ -5,9 +5,19 @@ package bjc.dicelang.dice;
  *
  * @author EVE
  *
+ * @TODO 10/08/17 Ben Culkin :DieListGeneralize
+ * 	DieList in general should be changed to be able to be
+ * 	constructed from an arbitrary die using rollSingle and things
+ * 	like that.
  */
 public class SimpleDieList implements DieList {
+	/* The number of dice to roll. */
 	private final Die       numDice;
+	/* 
+	 * The size of each die to roll.
+	 *
+	 * Checked once per roll, not once per dice rolled.
+	 */
 	private final Die       size;
 
 	/**
@@ -64,4 +74,4 @@ public class SimpleDieList implements DieList {
 	public String toString() {
 		return numDice.toString() + "dl" + size.toString();
 	}
-}
\ No newline at end of file
+}