diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc')
11 files changed, 328 insertions, 0 deletions
diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDiceExpression.java new file mode 100644 index 0000000..c4ebbe5 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/CompoundDiceExpression.java @@ -0,0 +1,34 @@ +package bjc.utils.dice; + +public class CompoundDiceExpression implements DiceExpression { + private DiceExpressionType det; + private DiceExpression left; + + private DiceExpression right; + + public CompoundDiceExpression(DiceExpression right, + DiceExpression left, DiceExpressionType det) { + this.right = right; + this.left = left; + this.det = det; + } + + @Override + public int roll() { + switch (det) { + case ADD: + return right.roll() + left.roll(); + case SUBTRACT: + return right.roll() - left.roll(); + case MULTIPLY: + return right.roll() * left.roll(); + case DIVIDE: + return Math.round(right.roll() / left.roll()); + default: + throw new IllegalStateException( + "Got passed a invalid ScalarExpressionType " + + det); + + } + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/Dice.java b/BJC-Utils2/src/main/java/bjc/utils/dice/Dice.java new file mode 100644 index 0000000..84c2d0a --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/Dice.java @@ -0,0 +1,39 @@ +package bjc.utils.dice; + +public class Dice implements DiceExpression { + private Die die; + private int nDice; + + public Dice(int nDce, Die de) { + nDice = nDce; + die = de; + } + + public Dice(int nDce, int nSides) { + this(nDce, new Die(nSides)); + } + + public int roll() { + int res = 0; + + for (int i = 0; i < nDice; i++) { + res += die.roll(); + } + + return res; + } + + public static Dice fromString(String dice) { + String[] strangs = dice.split("d"); + + try { + return new Dice(Integer.parseInt(strangs[0]), + Integer.parseInt(strangs[1])); + } catch (NumberFormatException nfex) { + throw new IllegalStateException( + "Attempted to create a dice using something that's not" + + " an integer: " + strangs[0] + " and " + + strangs[1] + " are likely culprits.s"); + } + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpression.java new file mode 100644 index 0000000..cd68918 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpression.java @@ -0,0 +1,5 @@ +package bjc.utils.dice; + +public interface DiceExpression { + public int roll(); +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionBuilder.java b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionBuilder.java new file mode 100644 index 0000000..bcfbb81 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionBuilder.java @@ -0,0 +1,63 @@ +package bjc.utils.dice; + +import static bjc.utils.dice.DiceExpressionType.*; + +public class DiceExpressionBuilder { + private DiceExpression baking; + + public DiceExpressionBuilder(Dice firstDice) { + baking = firstDice; + } + + public DiceExpressionBuilder(DiceExpression seed) { + baking = seed; + } + + public DiceExpressionBuilder(int nSides, int nDice) { + baking = new Dice(nSides, nDice); + } + + public DiceExpressionBuilder add(DiceExpression exp) { + baking = new CompoundDiceExpression(baking, exp, ADD); + return this; + } + + public DiceExpressionBuilder add(int num) { + baking = new ScalarDiceExpression(baking, num, ADD); + return this; + } + + public DiceExpression bake() { + return baking; + } + + public DiceExpressionBuilder divide(DiceExpression exp) { + baking = new CompoundDiceExpression(baking, exp, DIVIDE); + return this; + } + + public DiceExpressionBuilder divide(int num) { + baking = new ScalarDiceExpression(baking, num, DIVIDE); + return this; + } + + public DiceExpressionBuilder multiply(DiceExpression exp) { + baking = new CompoundDiceExpression(baking, exp, MULTIPLY); + return this; + } + + public DiceExpressionBuilder multiply(int num) { + baking = new ScalarDiceExpression(baking, num, MULTIPLY); + return this; + } + + public DiceExpressionBuilder subtract(DiceExpression exp) { + baking = new CompoundDiceExpression(baking, exp, SUBTRACT); + return this; + } + + public DiceExpressionBuilder subtract(int num) { + baking = new ScalarDiceExpression(baking, num, SUBTRACT); + return this; + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParser.java b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParser.java new file mode 100644 index 0000000..3be56e4 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParser.java @@ -0,0 +1,57 @@ +package bjc.utils.dice; + +import java.util.Stack; + +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.parserutils.ShuntingYard; + +public class DiceExpressionParser { + public DiceExpression parse(String exp) { + FunctionalStringTokenizer fst = new FunctionalStringTokenizer(exp); + + ShuntingYard<String> yard = new ShuntingYard<>(); + + FunctionalList<String> ls = yard.postfix(fst.toList(s -> s), + s -> s); + + Stack<DiceExpression> dexps = new Stack<>(); + + ls.forEach((tok) -> { + if (tok.contains("d")) { + dexps.push(Dice.fromString(tok)); + } else { + try { + dexps.push(new ScalarDie(Integer.parseInt(tok))); + } catch (NumberFormatException nfex) { + + DiceExpression l = dexps.pop(); + DiceExpression r = dexps.pop(); + + switch (tok) { + case "+": + dexps.push(new CompoundDiceExpression(l, r, + DiceExpressionType.ADD)); + break; + case "-": + dexps.push(new CompoundDiceExpression(l, r, + DiceExpressionType.SUBTRACT)); + break; + case "*": + dexps.push(new CompoundDiceExpression(l, r, + DiceExpressionType.MULTIPLY)); + break; + case "/": + dexps.push(new CompoundDiceExpression(l, r, + DiceExpressionType.DIVIDE)); + break; + default: + throw new IllegalStateException("Detected invalid operator " + tok); + } + } + } + }); + + return dexps.pop(); + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParserTest.java b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParserTest.java new file mode 100644 index 0000000..ff95ef3 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionParserTest.java @@ -0,0 +1,29 @@ +package bjc.utils.dice; + +import java.util.Scanner; + +public class DiceExpressionParserTest { + public static void main(String[] args) { + Scanner scn = new Scanner(System.in); + + System.out.print("Enter dice expression: "); + + String exp = scn.nextLine(); + + System.out.print("Enter number of times to roll: "); + + int nTimes = Integer.parseInt(scn.nextLine()); + + DiceExpressionParser dep = new DiceExpressionParser(); + + DiceExpression dexp = dep.parse(exp); + + for(int i = 1; i <= nTimes; i++) { + int roll = dexp.roll(); + + System.out.println("Rolled " + roll); + } + + scn.close(); + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java new file mode 100644 index 0000000..eb573ed --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/DiceExpressionType.java @@ -0,0 +1,5 @@ +package bjc.utils.dice; + +public enum DiceExpressionType { + ADD, DIVIDE, MULTIPLY, SUBTRACT +}
\ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/Die.java b/BJC-Utils2/src/main/java/bjc/utils/dice/Die.java new file mode 100644 index 0000000..9998ae7 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/Die.java @@ -0,0 +1,17 @@ +package bjc.utils.dice; + +import java.util.Random; + +public class Die { + private static Random rng = new Random(); + + private int nSides; + + public Die(int nSides) { + this.nSides = nSides; + } + + public int roll() { + return rng.nextInt(nSides + 1); + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/PolyhedralDice.java b/BJC-Utils2/src/main/java/bjc/utils/dice/PolyhedralDice.java new file mode 100644 index 0000000..a8bebe6 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/PolyhedralDice.java @@ -0,0 +1,31 @@ +package bjc.utils.dice; + +public class PolyhedralDice { + public static Dice d10(int nDice) { + return new Dice(nDice, 10); + } + + public static Dice d100(int nDice) { + return new Dice(nDice, 100); + } + + public static Dice d12(int nDice) { + return new Dice(nDice, 12); + } + + public static Dice d20(int nDice) { + return new Dice(nDice, 20); + } + + public static Dice d4(int nDice) { + return new Dice(nDice, 4); + } + + public static Dice d6(int nDice) { + return new Dice(nDice, 6); + } + + public static Dice d8(int nDice) { + return new Dice(nDice, 8); + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDiceExpression.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDiceExpression.java new file mode 100644 index 0000000..4b73dd5 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDiceExpression.java @@ -0,0 +1,33 @@ +package bjc.utils.dice; + +public class ScalarDiceExpression implements DiceExpression { + private DiceExpressionType det; + private DiceExpression exp; + + private int scalar; + + public ScalarDiceExpression(DiceExpression dex, int scalr, + DiceExpressionType dt) { + exp = dex; + scalar = scalr; + det = dt; + } + + @Override + public int roll() { + switch (det) { + case ADD: + return exp.roll() + scalar; + case SUBTRACT: + return exp.roll() - scalar; + case MULTIPLY: + return exp.roll() * scalar; + case DIVIDE: + return Math.round(exp.roll() / scalar); + default: + throw new IllegalStateException( + "Got passed a invalid ScalarExpressionType " + + det); + } + } +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDie.java b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDie.java new file mode 100644 index 0000000..7694afd --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/dice/ScalarDie.java @@ -0,0 +1,15 @@ +package bjc.utils.dice; + +public class ScalarDie implements DiceExpression { + private int num; + + @Override + public int roll() { + return num; + } + + public ScalarDie(int num) { + this.num = num; + } + +} |