From 40858cee415643769ee5f6216b0cd4335996ff2f Mon Sep 17 00:00:00 2001 From: bjculkin Date: Tue, 11 Apr 2017 17:51:13 -0400 Subject: General cleanup and fixes --- dice-lang/src/bjc/dicelang/dice/DiceBox.java | 66 +++---- dice-lang/src/bjc/dicelang/dice/DieExpression.java | 130 +++++++------- dice-lang/src/bjc/dicelang/dice/DieList.java | 63 ++++--- dice-lang/src/bjc/dicelang/dice/FudgeDie.java | 110 +++++++----- dice-lang/src/bjc/dicelang/dice/MathDie.java | 193 ++++++++++++--------- dice-lang/src/bjc/dicelang/dice/ScalarDie.java | 78 +++++---- dice-lang/src/bjc/dicelang/dice/SimpleDie.java | 173 +++++++++++------- dice-lang/src/bjc/dicelang/dice/SimpleDieList.java | 115 ++++++------ 8 files changed, 526 insertions(+), 402 deletions(-) (limited to 'dice-lang/src/bjc/dicelang/dice') diff --git a/dice-lang/src/bjc/dicelang/dice/DiceBox.java b/dice-lang/src/bjc/dicelang/dice/DiceBox.java index 7a7e7c4..2147a06 100644 --- a/dice-lang/src/bjc/dicelang/dice/DiceBox.java +++ b/dice-lang/src/bjc/dicelang/dice/DiceBox.java @@ -15,26 +15,30 @@ public class DiceBox { /** * Parse a die expression from a string. * + * @param expString + * The string to parse. + * * @return The die expression from the string, or null if it wasn't one */ - public static DieExpression parseExpression(String exp) { + public static DieExpression parseExpression(String expString) { /* - * Only bother will valid expressions + * Only bother with valid expressions. */ - if(!isValidExpression(exp)) return null; + if(!isValidExpression(expString)) return null; - if(scalarDiePattern.matcher(exp).matches()) { + if(scalarDiePattern.matcher(expString).matches()) { /* - * Parse scalar die + * Parse scalar die. */ - Die scal = new ScalarDie(Long.parseLong(exp.substring(0, exp.indexOf('s')))); + String dieString = expString.substring(0, expString.indexOf('s')); + Die scal = new ScalarDie(Long.parseLong(dieString)); return new DieExpression(scal); - } else if(simpleDiePattern.matcher(exp).matches()) { + } else if(simpleDiePattern.matcher(expString).matches()) { /* - * Parse simple die groups + * Parse simple die groups. */ - String[] dieParts = exp.split("d"); + String[] dieParts = expString.split("d"); long right = Long.parseLong(dieParts[1]); if(dieParts[0].equals("")) { @@ -47,61 +51,61 @@ public class DiceBox { Die scal = new SimpleDie(Long.parseLong(dieParts[0]), right); return new DieExpression(scal); } - } else if(fudgeDiePattern.matcher(exp).matches()) { + } else if(fudgeDiePattern.matcher(expString).matches()) { /* - * Parse fudge dice + * Parse fudge dice. */ - String nDice = exp.substring(0, exp.indexOf('d')); + String nDice = expString.substring(0, expString.indexOf('d')); return new DieExpression(new FudgeDie(Long.parseLong(nDice))); - } else if(compoundDiePattern.matcher(exp).matches()) { + } else if(compoundDiePattern.matcher(expString).matches()) { /* - * Parse compound die expressions + * Parse compound die expressions. */ - String[] dieParts = exp.split("c"); + String[] dieParts = expString.split("c"); DieExpression left = parseExpression(dieParts[0]); DieExpression right = parseExpression(dieParts[1]); return new DieExpression(new CompoundDie(left.scalar, right.scalar)); - } else if(compoundingDiePattern.matcher(exp).matches()) { + } else if(compoundingDiePattern.matcher(expString).matches()) { /* - * Parse compounding die expressions + * Parse compounding die expressions. */ - String[] dieParts = exp.split("!!"); + String[] dieParts = expString.split("!!"); DieExpression left = parseExpression(dieParts[0]); Predicate right = deriveCond(dieParts[1]); Die scal = new CompoundingDie(left.scalar, right, dieParts[1]); return new DieExpression(scal); - } else if(explodingDiePattern.matcher(exp).matches()) { + } else if(explodingDiePattern.matcher(expString).matches()) { /* - * Parse exploding die expressions + * Parse exploding die expressions. */ - String[] dieParts = exp.split("!"); + String[] dieParts = expString.split("!"); DieExpression left = parseExpression(dieParts[0]); Predicate right = deriveCond(dieParts[1]); DieList lst = new ExplodingDice(left.scalar, right, dieParts[1], false); return new DieExpression(lst); - } else if(penetratingDiePattern.matcher(exp).matches()) { + } else if(penetratingDiePattern.matcher(expString).matches()) { /* - * Parse penetrating die expressions + * Parse penetrating die expressions. */ - String[] dieParts = exp.split("p!"); + String[] dieParts = expString.split("p!"); DieExpression left = parseExpression(dieParts[0]); Predicate right = deriveCond(dieParts[1]); DieList lst = new ExplodingDice(left.scalar, right, dieParts[1], true); return new DieExpression(lst); - } else if(diceListPattern.matcher(exp).matches()) { + } else if(diceListPattern.matcher(expString).matches()) { /* - * Parse simple die lists + * Parse simple die lists. */ - String[] dieParts = exp.split("dl"); + String[] dieParts = expString.split("dl"); DieExpression left = parseExpression(dieParts[0]); DieExpression right = parseExpression(dieParts[1]); @@ -114,11 +118,11 @@ public class DiceBox { } /* - * The strings and patterns used for matching + * The strings and patterns used for matching. */ /* - * Defines a comparison predicate + * Defines a comparison predicate. */ private static final String comparePoint = "[<>=]\\d+"; @@ -193,7 +197,7 @@ public class DiceBox { /* * Defines a die list. * - * This is an array of dice of the specified size + * This is an array of dice of the specified size. */ private static final String diceList = compoundGroup + "dl" + compoundGroup; private static final Pattern diceListPattern = Pattern.compile("\\A" + diceList + "\\Z"); @@ -204,7 +208,7 @@ public class DiceBox { * @param exp * The string to check validity of. * - * @return Whether or not the string is a valid command + * @return Whether or not the string is a valid command. */ public static boolean isValidExpression(String exp) { if(scalarDiePattern.matcher(exp).matches()) diff --git a/dice-lang/src/bjc/dicelang/dice/DieExpression.java b/dice-lang/src/bjc/dicelang/dice/DieExpression.java index 576660d..92625eb 100644 --- a/dice-lang/src/bjc/dicelang/dice/DieExpression.java +++ b/dice-lang/src/bjc/dicelang/dice/DieExpression.java @@ -1,64 +1,66 @@ -package bjc.dicelang.dice; - -import java.util.Arrays; - -/** - * Represents either a die or a die list - * - * @author Ben Culkin - */ -public class DieExpression { - /** - * Is this expression a list? - */ - public final boolean isList; - - /** - * The scalar value in this expression, if there is one. - */ - public Die scalar; - /** - * The list value in this expression, if there is one. - */ - public DieList list; - - /** - * Create a scalar die expression. - * - * @param scal - * The scalar value of this expression. - */ - public DieExpression(Die scal) { - isList = false; - scalar = scal; - } - - /** - * Create a list die expression. - * - * @param lst - * The list value of this expression. - */ - public DieExpression(DieList lst) { - isList = true; - list = lst; - } - - @Override - public String toString() { - if(isList) - return list.toString(); - else - return scalar.toString(); - } - - /** - * Get the value of this expression as a string. - */ - public String value() { - if(isList) - return Arrays.toString(list.roll()); - else - return Long.toString(scalar.roll()); - } -} +package bjc.dicelang.dice; + +import java.util.Arrays; + +/** + * Represents either a die or a die list. + * + * @author Ben Culkin + */ +public class DieExpression { + /** + * Is this expression a list? + */ + public final boolean isList; + + /** + * The scalar value in this expression, if there is one. + */ + public Die scalar; + /** + * The list value in this expression, if there is one. + */ + public DieList list; + + /** + * Create a scalar die expression. + * + * @param scal + * The scalar value of this expression. + */ + public DieExpression(Die scal) { + isList = false; + scalar = scal; + } + + /** + * Create a list die expression. + * + * @param lst + * The list value of this expression. + */ + public DieExpression(DieList lst) { + isList = true; + list = lst; + } + + @Override + public String toString() { + if(isList) + return list.toString(); + else + return scalar.toString(); + } + + /** + * Get the value of this expression as a string. + * + * @return The value of the expression as a string. + */ + public String value() { + if(isList) + return Arrays.toString(list.roll()); + else + return Long.toString(scalar.roll()); + } +} diff --git a/dice-lang/src/bjc/dicelang/dice/DieList.java b/dice-lang/src/bjc/dicelang/dice/DieList.java index 5cabc77..48006d4 100644 --- a/dice-lang/src/bjc/dicelang/dice/DieList.java +++ b/dice-lang/src/bjc/dicelang/dice/DieList.java @@ -1,32 +1,31 @@ -package bjc.dicelang.dice; - -/** - * Represents a group of dice. - * - * @author Ben Culkin. - */ -public interface DieList { - /** - * Can this list be optimized? - * - * @return Whether or not this list cna be optimized. - */ - boolean canOptimize(); - - /** - * Optimize this list, if it can be done. - * - * Invoking this on unoptimizable expression is undefined. - * - * @return The optimized form of this list. - */ - long[] optimize(); - - /** - * Roll this group of dice. - * - * @param A - * possible roll of this group. - */ - long[] roll(); -} +package bjc.dicelang.dice; + +/** + * Represents a group of dice. + * + * @author Ben Culkin. + */ +public interface DieList { + /** + * Can this list be optimized? + * + * @return Whether or not this list can be optimized. + */ + boolean canOptimize(); + + /** + * Optimize this list, if it can be done. + * + * Invoking this on unoptimizable expression is undefined. + * + * @return The optimized form of this list. + */ + long[] optimize(); + + /** + * Roll this group of dice. + * + * @return A possible roll of this group. + */ + long[] roll(); +} diff --git a/dice-lang/src/bjc/dicelang/dice/FudgeDie.java b/dice-lang/src/bjc/dicelang/dice/FudgeDie.java index 0385239..5e5125f 100644 --- a/dice-lang/src/bjc/dicelang/dice/FudgeDie.java +++ b/dice-lang/src/bjc/dicelang/dice/FudgeDie.java @@ -1,46 +1,64 @@ -package bjc.dicelang.dice; - -public class FudgeDie implements Die { - private Die numDice; - - public FudgeDie(long nDice) { - numDice = new ScalarDie(nDice); - } - - public FudgeDie(Die nDice) { - numDice = nDice; - } - - @Override - public boolean canOptimize() { - return numDice.canOptimize() && numDice.optimize() == 0; - } - - @Override - public long optimize() { - return 0; - } - - @Override - public long roll() { - long res = 0; - - long nDice = numDice.roll(); - - for(int i = 0; i < nDice; i++) { - res += rollSingle(); - } - - return res; - } - - @Override - public long rollSingle() { - return DiceBox.rng.nextInt(3) - 1; - } - - @Override - public String toString() { - return numDice + "dF"; - } -} +package bjc.dicelang.dice; + +/** + * A fudge die, one that has -1, 0 and 1 as its sides. + * + * @author EVE + * + */ +public class FudgeDie implements Die { + private Die numDice; + + /** + * Create a new fudge die. + * + * @param nDice + * The number of dice to roll. + */ + public FudgeDie(long nDice) { + numDice = new ScalarDie(nDice); + } + + /** + * Create a new fudge die. + * + * @param nDice + * The number of dice to roll. + */ + public FudgeDie(Die nDice) { + numDice = nDice; + } + + @Override + public boolean canOptimize() { + return numDice.canOptimize() && numDice.optimize() == 0; + } + + @Override + public long optimize() { + return 0; + } + + @Override + public long roll() { + long res = 0; + + long nDice = numDice.roll(); + + for(int i = 0; i < nDice; i++) { + res += rollSingle(); + } + + return res; + } + + @Override + public long rollSingle() { + return DiceBox.rng.nextInt(3) - 1; + } + + @Override + public String toString() { + return numDice + "dF"; + } +} diff --git a/dice-lang/src/bjc/dicelang/dice/MathDie.java b/dice-lang/src/bjc/dicelang/dice/MathDie.java index 1d6b2fa..aba58a3 100644 --- a/dice-lang/src/bjc/dicelang/dice/MathDie.java +++ b/dice-lang/src/bjc/dicelang/dice/MathDie.java @@ -1,80 +1,115 @@ -package bjc.dicelang.dice; - -public class MathDie implements Die { - public static enum MathOp { - ADD, SUBTRACT, MULTIPLY; - - @Override - public String toString() { - switch(this) { - case ADD: - return "+"; - case SUBTRACT: - return "-"; - case MULTIPLY: - return "*"; - default: - return this.name(); - } - } - } - - private MathDie.MathOp type; - - private Die left; - private Die right; - - public MathDie(MathDie.MathOp op, Die lft, Die rght) { - type = op; - - left = lft; - right = rght; - } - - @Override - public boolean canOptimize() { - return left.canOptimize() && right.canOptimize(); - } - - private long performOp(long lft, long rght) { - switch(type) { - case ADD: - return lft + rght; - case SUBTRACT: - return lft - rght; - case MULTIPLY: - return lft * rght; - default: - return 0; - } - } - - @Override - public long optimize() { - long lft = left.optimize(); - long rght = right.optimize(); - - return performOp(lft, rght); - } - - @Override - public long roll() { - long lft = left.roll(); - long rght = right.roll(); - - return performOp(lft, rght); - } - - @Override - public long rollSingle() { - long lft = left.rollSingle(); - long rght = right.rollSingle(); - - return performOp(lft, rght); - } - - @Override - public String toString() { - return left.toString() + " " + type.toString() + " " + right.toString(); - } +package bjc.dicelang.dice; + +/** + * A die that represents two dice with an applied math operator. + * + * @author EVE + * + */ +public class MathDie implements Die { + /** + * The types of a math operator. + * + * @author EVE + * + */ + public static enum MathOp { + /** + * Add two dice. + */ + ADD, + /** + * Subtract two dice. + */ + SUBTRACT, + /** + * Multiply two dice. + */ + MULTIPLY; + + @Override + public String toString() { + switch(this) { + case ADD: + return "+"; + case SUBTRACT: + return "-"; + case MULTIPLY: + return "*"; + default: + return this.name(); + } + } + } + + private MathDie.MathOp type; + + private Die left; + private Die right; + + /** + * Create a new math die. + * + * @param op + * The operator to apply. + * + * @param lft + * The left operand. + * + * @param rght + * The right operand. + */ + public MathDie(MathDie.MathOp op, Die lft, Die rght) { + type = op; + + left = lft; + right = rght; + } + + @Override + public boolean canOptimize() { + return left.canOptimize() && right.canOptimize(); + } + + private long performOp(long lft, long rght) { + switch(type) { + case ADD: + return lft + rght; + case SUBTRACT: + return lft - rght; + case MULTIPLY: + return lft * rght; + default: + return 0; + } + } + + @Override + public long optimize() { + long lft = left.optimize(); + long rght = right.optimize(); + + return performOp(lft, rght); + } + + @Override + public long roll() { + long lft = left.roll(); + long rght = right.roll(); + + return performOp(lft, rght); + } + + @Override + public long rollSingle() { + long lft = left.rollSingle(); + long rght = right.rollSingle(); + + return performOp(lft, rght); + } + + @Override + 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 b9c3eba..0cb9af1 100644 --- a/dice-lang/src/bjc/dicelang/dice/ScalarDie.java +++ b/dice-lang/src/bjc/dicelang/dice/ScalarDie.java @@ -1,34 +1,46 @@ -package bjc.dicelang.dice; - -public class ScalarDie implements Die { - private long val; - - public ScalarDie(long vl) { - val = vl; - } - - @Override - public boolean canOptimize() { - return true; - } - - @Override - public long optimize() { - return val; - } - - @Override - public long roll() { - return val; - } - - @Override - public long rollSingle() { - return val; - } - - @Override - public String toString() { - return Long.toString(val); - } +package bjc.dicelang.dice; + +/** + * A scalar die, that always returns a given number. + * + * @author EVE + * + */ +public class ScalarDie implements Die { + private long val; + + /** + * Create a new scalar die with a set value. + * + * @param vl + * The value to use. + */ + public ScalarDie(long vl) { + val = vl; + } + + @Override + public boolean canOptimize() { + return true; + } + + @Override + public long optimize() { + return val; + } + + @Override + public long roll() { + return val; + } + + @Override + public long rollSingle() { + return val; + } + + @Override + public String toString() { + return Long.toString(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 f8dd945..68050e0 100644 --- a/dice-lang/src/bjc/dicelang/dice/SimpleDie.java +++ b/dice-lang/src/bjc/dicelang/dice/SimpleDie.java @@ -1,68 +1,107 @@ -package bjc.dicelang.dice; - -public class SimpleDie implements Die { - private Die numDice; - private Die diceSize; - - public SimpleDie(long nDice, long size) { - numDice = new ScalarDie(nDice); - diceSize = new ScalarDie(size); - } - - public SimpleDie(Die nDice, long size) { - numDice = nDice; - diceSize = new ScalarDie(size); - } - - public SimpleDie(long nDice, Die size) { - numDice = new ScalarDie(nDice); - diceSize = size; - } - - public SimpleDie(Die nDice, Die size) { - numDice = nDice; - diceSize = size; - } - - @Override - public boolean canOptimize() { - if(diceSize.canOptimize() && diceSize.optimize() <= 1) - return numDice.canOptimize(); - else - return false; - } - - @Override - public long optimize() { - long optSize = diceSize.optimize(); - - if(optSize == 0) - return 0; - else - return numDice.optimize(); - } - - @Override - public long roll() { - long total = 0; - - long nDice = numDice.roll(); - long dSize = diceSize.roll(); - - for(int i = 0; i < nDice; i++) { - total += Math.abs(DiceBox.rng.nextLong()) % dSize + 1; - } - - return total; - } - - @Override - public long rollSingle() { - return Math.abs(DiceBox.rng.nextLong()) % diceSize.roll() + 1; - } - - @Override - public String toString() { - return numDice + "d" + diceSize; - } +package bjc.dicelang.dice; + +/** + * A simple group of dice. + * + * @author EVE + * + */ +public class SimpleDie implements Die { + private Die numDice; + private Die diceSize; + + /** + * Create a new dice group. + * + * @param nDice + * The number of dice. + * + * @param size + * The size of the dice. + */ + public SimpleDie(long nDice, long size) { + this(new ScalarDie(nDice), new ScalarDie(size)); + } + + /** + * Create a new dice group. + * + * @param nDice + * The number of dice. + * + * @param size + * The size of the dice. + */ + public SimpleDie(Die nDice, long size) { + this(nDice, new ScalarDie(size)); + } + + /** + * Create a new dice group. + * + * @param nDice + * The number of dice. + * + * @param size + * The size of the dice. + */ + public SimpleDie(long nDice, Die size) { + this(new ScalarDie(nDice), size); + } + + /** + * Create a new dice group. + * + * @param nDice + * The number of dice. + * + * @param size + * The size of the dice. + */ + public SimpleDie(Die nDice, Die size) { + numDice = nDice; + diceSize = size; + } + + @Override + public boolean canOptimize() { + if(diceSize.canOptimize() && diceSize.optimize() <= 1) + return numDice.canOptimize(); + else + return false; + } + + @Override + public long optimize() { + long optSize = diceSize.optimize(); + + if(optSize == 0) + return 0; + else + return numDice.optimize(); + } + + @Override + public long roll() { + long total = 0; + + long nDice = numDice.roll(); + long dSize = diceSize.roll(); + + for(int i = 0; i < nDice; i++) { + total += Math.abs(DiceBox.rng.nextLong()) % dSize + 1; + } + + return total; + } + + @Override + public long rollSingle() { + return Math.abs(DiceBox.rng.nextLong()) % diceSize.roll() + 1; + } + + @Override + 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 54f8e7a..d5d8364 100644 --- a/dice-lang/src/bjc/dicelang/dice/SimpleDieList.java +++ b/dice-lang/src/bjc/dicelang/dice/SimpleDieList.java @@ -1,51 +1,66 @@ -package bjc.dicelang.dice; - -public class SimpleDieList implements DieList { - private Die numDice; - private Die size; - - public SimpleDieList(Die nDice, Die sze) { - numDice = nDice; - size = sze; - } - - @Override - public boolean canOptimize() { - if(size.canOptimize() && size.optimize() <= 1) - return numDice.canOptimize(); - else - return false; - } - - @Override - public long[] optimize() { - int sze = (int) numDice.optimize(); - long res = size.optimize(); - - long[] ret = new long[sze]; - - for(int i = 0; i < sze; i++) { - ret[i] = res; - } - - return ret; - } - - @Override - public long[] roll() { - int num = (int) numDice.roll(); - - long[] ret = new long[num]; - - for(int i = 0; i < num; i++) { - ret[i] = size.roll(); - } - - return ret; - } - - @Override - public String toString() { - return numDice.toString() + "dl" + size.toString(); - } +package bjc.dicelang.dice; + +/** + * A simple list of dice. + * + * @author EVE + * + */ +public class SimpleDieList implements DieList { + private Die numDice; + private Die size; + + /** + * Create a new list of dice. + * + * @param nDice + * The number of dice in the list. + * + * @param sze + * The size of dice in the list. + */ + public SimpleDieList(Die nDice, Die sze) { + numDice = nDice; + size = sze; + } + + @Override + public boolean canOptimize() { + if(size.canOptimize() && size.optimize() <= 1) + return numDice.canOptimize(); + else + return false; + } + + @Override + public long[] optimize() { + int sze = (int) numDice.optimize(); + long res = size.optimize(); + + long[] ret = new long[sze]; + + for(int i = 0; i < sze; i++) { + ret[i] = res; + } + + return ret; + } + + @Override + public long[] roll() { + int num = (int) numDice.roll(); + + long[] ret = new long[num]; + + for(int i = 0; i < num; i++) { + ret[i] = size.roll(); + } + + return ret; + } + + @Override + public String toString() { + return numDice.toString() + "dl" + size.toString(); + } } \ No newline at end of file -- cgit v1.2.3