diff options
Diffstat (limited to 'dice-lang/src/main/java')
10 files changed, 220 insertions, 175 deletions
diff --git a/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java b/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java index 9b8f0bd..7ed4e3b 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java +++ b/dice-lang/src/main/java/bjc/dicelang/ComplexDice.java @@ -11,15 +11,15 @@ public class ComplexDice implements IDiceExpression { /** * Create a dice from a string expression * - * @param dice + * @param expression * The string to parse the dice from * @return A dice group parsed from the string */ - public static IDiceExpression fromString(String dice) { + public static IDiceExpression fromString(String expression) { /* * Split it on the dice type marker */ - String[] strangs = dice.split("d"); + String[] strangs = expression.split("d"); try { /* @@ -129,6 +129,11 @@ public class ComplexDice implements IDiceExpression { @Override public int optimize() { + if (!canOptimize()) { + throw new UnsupportedOperationException( + "This complex dice cannot be optimized"); + } + return nDice.optimize(); } }
\ No newline at end of file diff --git a/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java b/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java index 6f7319a..8d2aadd 100644 --- a/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java +++ b/dice-lang/src/main/java/bjc/dicelang/CompoundDice.java @@ -13,48 +13,65 @@ public class CompoundDice implements IDiceExpression { /** * The left die of the expression */ - private IDiceExpression l; + private IDiceExpression leftDice; /** * The right die of the expression */ - private IDiceExpression r; + private IDiceExpression rightDice; /** * Create a new compound dice using the specified dice * - * @param l + * @param left * The die to use on the left - * @param r + * @param right * The die to use on the right */ - public CompoundDice(IDiceExpression l, IDiceExpression r) { - this.l = l; - this.r = r; + public CompoundDice(IDiceExpression left, IDiceExpression right) { + this.leftDice = left; + this.rightDice = right; } /** * Create a new compound dice from two dice strings * - * @param l - * The left side dice - * @param r - * The right side dice + * @param leftExp + * The left side dice as a string + * @param rightExp + * The right side dice as a string */ - public CompoundDice(String l, String r) { - this(ComplexDice.fromString(l), ComplexDice.fromString(r)); + public CompoundDice(String leftExp, String rightExp) { + this(ComplexDice.fromString(leftExp), + ComplexDice.fromString(rightExp)); } /** * Create a new compound dice from an array of dice strings * * @param exps - * An array of dice strings + * An array of two dice strings */ public CompoundDice(String[] exps) { this(exps[0], exps[1]); } + @Override + public boolean canOptimize() { + return leftDice.canOptimize() && rightDice.canOptimize(); + } + + @Override + public int optimize() { + if (!canOptimize()) { + throw new UnsupportedOperationException( + "Cannot optimize this compound dice"); + } + + return Integer + .parseInt(leftDice.optimize() + "" + rightDice.optimize()); + } + /* * (non-Javadoc) * @@ -65,7 +82,7 @@ public class CompoundDice implements IDiceExpression { /* * Make the combination of the two dice */ - return Integer.parseInt(l.roll() + "" + r.roll()); + return Integer.parseInt(leftDice.roll() + "" + rightDice.roll()); } /* @@ -75,16 +92,7 @@ public class CompoundDice implements IDiceExpression { */ @Override public String toString() { - return "compound[l=" + l.toString() + ", r=" + r.toString() + "]"; - } - - @Override - public int optimize() { - return Integer.parseInt(l.optimize() + "" + r.optimize()); - } - - @Override - public boolean canOptimize() { - return l.canOptimize() && r.canOptimize(); + return "compound[l=" + leftDice.toString() + ", r=" + + rightDice.toString() + "]"; } }
\ No newline at end of file diff --git a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java index 8a8ded3..76ccdd4 100644 --- a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java +++ b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java @@ -19,18 +19,19 @@ public class DiceExpressionParser { /** * Parse a dice expression from a string * - * @param exp + * @param expression * The string to parse an expression from - * @param env + * @param enviroment * The enviroment to use when parsing expressions * @return The parsed dice expression */ - public static IDiceExpression parse(String exp, - Map<String, IDiceExpression> env) { + public static IDiceExpression parse(String expression, + Map<String, IDiceExpression> enviroment) { /* * Create a tokenizer over the strings */ - FunctionalStringTokenizer fst = new FunctionalStringTokenizer(exp); + FunctionalStringTokenizer tokenizer = + new FunctionalStringTokenizer(expression); /* * Create a shunter to rewrite the expression @@ -50,72 +51,90 @@ public class DiceExpressionParser { /* * Shunt the expression to postfix form */ - IFunctionalList<String> ls = yard.postfix(fst.toList(s -> s), - s -> s); + IFunctionalList<String> list = + yard.postfix(tokenizer.toList(), s -> s); /* * Create a stack for building an expression from parts */ - Stack<IDiceExpression> dexps = new Stack<>(); + Stack<IDiceExpression> expressions = new Stack<>(); /* * Create the expression from parts */ - ls.forEach((tok) -> { + list.forEach((expressionPart) -> { /* * Handle compound dice */ - if (StringUtils.countMatches(tok, 'c') == 1 - && !tok.equalsIgnoreCase("c")) { - String[] strangs = tok.split("c"); + if (StringUtils.countMatches(expressionPart, 'c') == 1 + && !expressionPart.equalsIgnoreCase("c")) { + String[] strangs = expressionPart.split("c"); - dexps.push(new CompoundDice(strangs)); - } else if (StringUtils.countMatches(tok, 'd') == 1 - && !tok.equalsIgnoreCase("d")) { + expressions.push(new CompoundDice(strangs)); + } else if (StringUtils.countMatches(expressionPart, 'd') == 1 + && !expressionPart.equalsIgnoreCase("d")) { /* * Handle dice groups */ - dexps.push(ComplexDice.fromString(tok)); + expressions.push(ComplexDice.fromString(expressionPart)); } else { try { /* * Handle scalar numbers */ - dexps.push(new ScalarDie(Integer.parseInt(tok))); + expressions.push(new ScalarDie( + Integer.parseInt(expressionPart))); } catch (@SuppressWarnings("unused") NumberFormatException nfex) { // We don't care about details, just that it failed - if (dexps.size() >= 2) { + if (expressions.size() >= 2) { /* * Apply an operation to two dice */ - IDiceExpression r = dexps.pop(); - IDiceExpression l = dexps.pop(); - switch (tok) { + IDiceExpression rightExpression = + expressions.pop(); + IDiceExpression leftExpression = expressions.pop(); + + switch (expressionPart) { case ":=": - dexps.push(new BindingDiceExpression(l, r, - env)); + expressions.push(new BindingDiceExpression( + leftExpression, rightExpression, + enviroment)); break; case "+": - dexps.push(new OperatorDiceExpression(r, l, - DiceExpressionType.ADD)); + expressions + .push(new OperatorDiceExpression( + rightExpression, + leftExpression, + DiceExpressionType.ADD)); break; case "-": - dexps.push(new OperatorDiceExpression(r, l, - DiceExpressionType.SUBTRACT)); + expressions + .push(new OperatorDiceExpression( + rightExpression, + leftExpression, + DiceExpressionType.SUBTRACT)); break; case "*": - dexps.push(new OperatorDiceExpression(r, l, - DiceExpressionType.MULTIPLY)); + expressions + .push(new OperatorDiceExpression( + rightExpression, + leftExpression, + DiceExpressionType.MULTIPLY)); break; case "/": - dexps.push(new OperatorDiceExpression(r, l, - DiceExpressionType.DIVIDE)); + expressions + .push(new OperatorDiceExpression( + rightExpression, + leftExpression, + DiceExpressionType.DIVIDE)); break; case "c": - dexps.push(new CompoundDice(l, r)); + expressions.push(new CompoundDice( + leftExpression, rightExpression)); break; case "d": - dexps.push(new ComplexDice(l, r)); + expressions.push(new ComplexDice( + leftExpression, rightExpression)); break; default: /* @@ -123,23 +142,26 @@ public class DiceExpressionParser { * * Make sure to restore popped variables */ - dexps.push(l); - dexps.push(r); + expressions.push(leftExpression); + expressions.push(rightExpression); - dexps.push(new ReferenceDiceExpression(tok, - env)); + expressions + .push(new ReferenceDiceExpression( + expressionPart, + enviroment)); } } else { /* * Parse it as a variable reference */ - dexps.push(new ReferenceDiceExpression(tok, env)); + expressions.push(new ReferenceDiceExpression( + expressionPart, enviroment)); } } } }); - if (dexps.size() != 1) { + if (expressions.size() != 1) { System.err.println( "WARNING: Leftovers found on dice expression stack. Remember, := is assignment."); } @@ -147,6 +169,6 @@ public class DiceExpressionParser { /* * Return the built expression */ - return dexps.pop(); + return expressions.pop(); } } diff --git a/dice-lang/src/main/java/bjc/dicelang/Die.java b/dice-lang/src/main/java/bjc/dicelang/Die.java index 5ad5d79..192daaa 100644 --- a/dice-lang/src/main/java/bjc/dicelang/Die.java +++ b/dice-lang/src/main/java/bjc/dicelang/Die.java @@ -34,6 +34,21 @@ public class Die implements IDiceExpression { this.nSides = nSides; } + @Override + public boolean canOptimize() { + return nSides == 1; + } + + @Override + public int optimize() { + if (nSides != 1) { + throw new UnsupportedOperationException( + "Can't optimize " + nSides + "-sided dice"); + } + + return 1; + } + /* * (non-Javadoc) * @@ -53,14 +68,4 @@ public class Die implements IDiceExpression { public String toString() { return "d" + nSides; } - - @Override - public int optimize() { - return 1; - } - - @Override - public boolean canOptimize() { - return nSides == 1; - } } diff --git a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java index 16e1761..013d69d 100644 --- a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java @@ -42,19 +42,20 @@ public interface IDiceExpression { /** * Parse this node into an expression - * @param exp The string to convert to an expression * - * @return The node in expression form + * @param expression + * The string to convert to an expression + * + * @return The string in expression form */ - static IDiceExpression toExpression(String exp) { - String literalData = exp; - + static IDiceExpression toExpression(String expression) { + String literalData = expression; + if (StringUtils.containsInfixOperator(literalData, "c")) { String[] strangs = literalData.split("c"); - + return new CompoundDice(strangs); - } else if (StringUtils.containsInfixOperator(literalData, - "d")) { + } else if (StringUtils.containsInfixOperator(literalData, "d")) { /* * Handle dice groups */ @@ -63,11 +64,13 @@ public interface IDiceExpression { try { return new ScalarDie(Integer.parseInt(literalData)); } catch (NumberFormatException nfex) { - UnsupportedOperationException usex = new UnsupportedOperationException( - "Found malformed leaf token " + exp); - + UnsupportedOperationException usex = + new UnsupportedOperationException( + "Found malformed leaf token " + + expression); + usex.initCause(nfex); - + throw usex; } } diff --git a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java index 4779bb9..2d47d85 100644 --- a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java @@ -10,17 +10,17 @@ public class OperatorDiceExpression implements IDiceExpression { /** * The operator to use for combining the dice */ - private DiceExpressionType det; + private DiceExpressionType expressionType; /** * The dice on the left side of the expression */ - private IDiceExpression left; + private IDiceExpression leftExpression; /** * The dice on the right side of the expression */ - private IDiceExpression right; + private IDiceExpression rightExpression; /** * Create a new compound expression using the specified parameters @@ -29,14 +29,14 @@ public class OperatorDiceExpression implements IDiceExpression { * The die on the right side of the expression * @param left * The die on the left side of the expression - * @param det + * @param type * The operator to use for combining the dices */ public OperatorDiceExpression(IDiceExpression right, - IDiceExpression left, DiceExpressionType det) { - this.right = right; - this.left = left; - this.det = det; + IDiceExpression left, DiceExpressionType type) { + this.rightExpression = right; + this.leftExpression = left; + this.expressionType = type; } /* @@ -49,26 +49,27 @@ public class OperatorDiceExpression implements IDiceExpression { /* * Handle each operator */ - switch (det) { + switch (expressionType) { case ADD: - return right.roll() + left.roll(); + return rightExpression.roll() + leftExpression.roll(); case SUBTRACT: - return right.roll() - left.roll(); + return rightExpression.roll() - leftExpression.roll(); case MULTIPLY: - return right.roll() * left.roll(); + return rightExpression.roll() * leftExpression.roll(); case DIVIDE: /* * Round to keep results as integers. We don't really have - * any need for floating-point dice + * any need for floating-point dice, and continuous + * probability is a pain */ try { - return right.roll() / left.roll(); + return rightExpression.roll() / leftExpression.roll(); } catch (ArithmeticException aex) { UnsupportedOperationException usex = new UnsupportedOperationException( "Attempted to divide by zero." + " Problematic expression is " - + left); + + leftExpression); usex.initCause(aex); @@ -76,8 +77,8 @@ public class OperatorDiceExpression implements IDiceExpression { } default: throw new IllegalArgumentException( - "Got passed a invalid ScalarExpressionType " + det - + ". WAT"); + "Got passed a invalid ScalarExpressionType " + + expressionType + ". WAT"); } } @@ -89,7 +90,8 @@ public class OperatorDiceExpression implements IDiceExpression { */ @Override public String toString() { - return "dice-exp[type=" + det + ", l=" + left.toString() + ", r=" - + right.toString() + "]"; + return "dice-exp[type=" + expressionType + ", l=" + + leftExpression.toString() + ", r=" + + rightExpression.toString() + "]"; } }
\ No newline at end of file diff --git a/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java b/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java index 9f609b4..3ac9420 100644 --- a/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java +++ b/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java @@ -8,6 +8,15 @@ package bjc.dicelang; */ public class PolyhedralDice { /** + * Produce a single d10 + * + * @return A single d10 + */ + public static IDiceExpression d10() { + return d10(1); + } + + /** * Produce the specified number of 10-sided dice * * @param nDice @@ -19,12 +28,12 @@ public class PolyhedralDice { } /** - * Produce a single d10 + * Produce a single d100 * - * @return A single d10 + * @return A single d100 */ - public static IDiceExpression d10() { - return d10(1); + public static IDiceExpression d100() { + return d100(1); } /** @@ -39,12 +48,12 @@ public class PolyhedralDice { } /** - * Produce a single d100 + * Produce a single d12 * - * @return A single d100 + * @return A single d12 */ - public static IDiceExpression d100() { - return d100(1); + public static IDiceExpression d12() { + return d12(1); } /** @@ -59,12 +68,12 @@ public class PolyhedralDice { } /** - * Produce a single d12 + * Produce a single d20 * - * @return A single d12 + * @return A single d20 */ - public static IDiceExpression d12() { - return d12(1); + public static IDiceExpression d20() { + return d20(1); } /** @@ -79,12 +88,12 @@ public class PolyhedralDice { } /** - * Produce a single d20 + * Produce a single d4 * - * @return A single d20 + * @return A single d4 */ - public static IDiceExpression d20() { - return d20(1); + public static IDiceExpression d4() { + return d4(1); } /** @@ -99,12 +108,12 @@ public class PolyhedralDice { } /** - * Produce a single d4 + * Produce a single d6 * - * @return A single d4 + * @return A single d6 */ - public static IDiceExpression d4() { - return d4(1); + public static IDiceExpression d6() { + return d6(1); } /** @@ -119,12 +128,12 @@ public class PolyhedralDice { } /** - * Produce a single d6 + * Produce a single d8 * - * @return A single d6 + * @return A single d8 */ - public static IDiceExpression d6() { - return d6(1); + public static IDiceExpression d8() { + return d8(1); } /** @@ -137,13 +146,4 @@ public class PolyhedralDice { public static IDiceExpression d8(int nDice) { return new ComplexDice(nDice, 8); } - - /** - * Produce a single d8 - * - * @return A single d8 - */ - public static IDiceExpression d8() { - return d8(1); - } } diff --git a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java index b7be527..61be936 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java @@ -13,12 +13,12 @@ public class ReferenceDiceExpression implements IDiceExpression { /** * The enviroment to do variable dereferencing against */ - private Map<String, IDiceExpression> env; + private Map<String, IDiceExpression> enviroment; /** * The name of the bound variable */ - private String name; + private String variableName; /** * Create a new reference dice expression referring to the given name @@ -31,8 +31,8 @@ public class ReferenceDiceExpression implements IDiceExpression { */ public ReferenceDiceExpression(String name, Map<String, IDiceExpression> env) { - this.name = name; - this.env = env; + this.variableName = name; + this.enviroment = env; } /** @@ -41,7 +41,7 @@ public class ReferenceDiceExpression implements IDiceExpression { * @return the name of the referenced variable */ public String getName() { - return name; + return variableName; } /* @@ -51,12 +51,12 @@ public class ReferenceDiceExpression implements IDiceExpression { */ @Override public int roll() { - if (!env.containsKey(name)) { + if (!enviroment.containsKey(variableName)) { throw new UnsupportedOperationException( - "Attempted to reference undefined variable " + name); + "Attempted to reference undefined variable " + variableName); } - return env.get(name).roll(); + return enviroment.get(variableName).roll(); } /* @@ -66,10 +66,10 @@ public class ReferenceDiceExpression implements IDiceExpression { */ @Override public String toString() { - if (env.containsKey(name)) { - return env.get(name).toString(); + if (enviroment.containsKey(variableName)) { + return enviroment.get(variableName).toString(); } - return name; + return variableName; } }
\ No newline at end of file diff --git a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java index d28633f..9c06c31 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java @@ -10,12 +10,12 @@ public class ScalarDiceExpression implements IDiceExpression { /** * The operation to combine with */ - private DiceExpressionType det; + private DiceExpressionType expressionType; /** * The expression to be combined */ - private IDiceExpression exp; + private IDiceExpression expression; /** * The scalar to be combined @@ -25,18 +25,18 @@ public class ScalarDiceExpression implements IDiceExpression { /** * Create a dice expression with a scalar * - * @param dex + * @param expr * The dice to use * @param scalr * The scalar to use - * @param dt + * @param type * The operation to combine with */ - public ScalarDiceExpression(IDiceExpression dex, int scalr, - DiceExpressionType dt) { - exp = dex; + public ScalarDiceExpression(IDiceExpression expr, int scalr, + DiceExpressionType type) { + expression = expr; scalar = scalr; - det = dt; + expressionType = type; } /* @@ -46,16 +46,16 @@ public class ScalarDiceExpression implements IDiceExpression { */ @Override public int roll() { - switch (det) { + switch (expressionType) { case ADD: - return exp.roll() + scalar; + return expression.roll() + scalar; case SUBTRACT: - return exp.roll() - scalar; + return expression.roll() - scalar; case MULTIPLY: - return exp.roll() * scalar; + return expression.roll() * scalar; case DIVIDE: try { - return exp.roll() / scalar; + return expression.roll() / scalar; } catch (ArithmeticException aex) { UnsupportedOperationException usex = new UnsupportedOperationException( @@ -68,7 +68,7 @@ public class ScalarDiceExpression implements IDiceExpression { default: throw new IllegalStateException( "Got passed a invalid ScalarExpressionType " - + det); + + expressionType); } } @@ -79,7 +79,7 @@ public class ScalarDiceExpression implements IDiceExpression { */ @Override public String toString() { - return "scalar-exp[type=" + det + ", l=" + scalar + ", r=" - + exp.toString() + "]"; + return "scalar-exp[type=" + expressionType + ", l=" + scalar + + ", r=" + expression.toString() + "]"; } }
\ No newline at end of file diff --git a/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java b/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java index fa25818..1d64dc2 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java +++ b/dice-lang/src/main/java/bjc/dicelang/ScalarDie.java @@ -10,7 +10,7 @@ public class ScalarDie implements IDiceExpression { /** * The represented number */ - private int num; + private int number; /** * Create a dice with the specified number @@ -19,7 +19,7 @@ public class ScalarDie implements IDiceExpression { * The number used for the dice */ public ScalarDie(int num) { - this.num = num; + this.number = num; } /* @@ -29,7 +29,7 @@ public class ScalarDie implements IDiceExpression { */ @Override public int roll() { - return num; + return number; } /* @@ -39,12 +39,12 @@ public class ScalarDie implements IDiceExpression { */ @Override public String toString() { - return Integer.toString(num); + return Integer.toString(number); } @Override public int optimize() { - return num; + return number; } @Override |