From b4316456105fc0c25943f8164697284125325e05 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Mon, 6 Mar 2017 14:48:42 -0500 Subject: Scalar/Fudge dice creation operators --- dice-lang/src/bjc/dicelang/Evaluator.java | 476 ++++++++++++++------------ dice-lang/src/bjc/dicelang/Parser.java | 2 + dice-lang/src/bjc/dicelang/Token.java | 21 +- dice-lang/src/bjc/dicelang/Tokenizer.java | 2 + dice-lang/src/bjc/dicelang/dice/FudgeDie.java | 6 +- 5 files changed, 268 insertions(+), 239 deletions(-) (limited to 'dice-lang') diff --git a/dice-lang/src/bjc/dicelang/Evaluator.java b/dice-lang/src/bjc/dicelang/Evaluator.java index 7b9bc83..1284479 100644 --- a/dice-lang/src/bjc/dicelang/Evaluator.java +++ b/dice-lang/src/bjc/dicelang/Evaluator.java @@ -1,7 +1,9 @@ package bjc.dicelang; import bjc.dicelang.dice.CompoundDie; +import bjc.dicelang.dice.FudgeDie; import bjc.dicelang.dice.MathDie; +import bjc.dicelang.dice.ScalarDie; import bjc.dicelang.dice.SimpleDie; import bjc.dicelang.dice.SimpleDieList; import bjc.utils.data.ITree; @@ -25,7 +27,7 @@ public class Evaluator { private static class Context { public Consumer>> thunk; - + public boolean isDebug; } @@ -80,95 +82,113 @@ public class Evaluator { private TopDownTransformResult pickEvaluationType(Node nd) { switch(nd.type) { - case UNARYOP: - switch(nd.operatorType) { - case COERCE: - return TopDownTransformResult.RTRANSFORM; - default: - return TopDownTransformResult.PUSHDOWN; - } + case UNARYOP: + switch(nd.operatorType) { + case COERCE: + return TopDownTransformResult.RTRANSFORM; default: return TopDownTransformResult.PUSHDOWN; + } + default: + return TopDownTransformResult.PUSHDOWN; } } private ITree evaluateNode(ITree ast, Context ctx) { switch(ast.getHead().type) { - case UNARYOP: - return evaluateUnaryOp(ast, ctx); - case BINOP: - return evaluateBinaryOp(ast, ctx); - case TOKREF: - return evaluateTokenRef(ast.getHead().tokenVal, ctx); - case ROOT: - return ast.getChild(ast.getChildrenCount() - 1); - case RESULT: - return ast; - default: - Errors.inst.printError(EK_EVAL_INVNODE, ast.getHead().type.toString()); - return new Tree<>(FAIL(ast)); + case UNARYOP: + return evaluateUnaryOp(ast, ctx); + case BINOP: + return evaluateBinaryOp(ast, ctx); + case TOKREF: + return evaluateTokenRef(ast.getHead().tokenVal, ctx); + case ROOT: + return ast.getChild(ast.getChildrenCount() - 1); + case RESULT: + return ast; + default: + Errors.inst.printError(EK_EVAL_INVNODE, ast.getHead().type.toString()); + return new Tree<>(FAIL(ast)); } } private ITree evaluateUnaryOp(ITree ast, Context ctx) { + if(ast.getChildrenCount() != 1) { + Errors.inst.printError(EK_EVAL_UNUNARY, Integer.toString(ast.getChildrenCount())); + return new Tree<>(FAIL(ast)); + } + switch(ast.getHead().operatorType) { - case COERCE: - if(ast.getChildrenCount() != 1) { - Errors.inst.printError(EK_EVAL_UNUNARY, Integer.toString(ast.getChildrenCount())); - return new Tree<>(FAIL(ast)); + case COERCE: + ITree toCoerce = ast.getChild(0); + ITree retVal = new Tree<>(toCoerce.getHead()); + Deque> children = new LinkedList<>(); + + CoerceSteps curLevel = CoerceSteps.INTEGER; + + for(int i = 0; i < toCoerce.getChildrenCount(); i++) { + ITree child = toCoerce.getChild(i); + ITree nChild = null; + + if(ctx.isDebug) { + Iterator> nd = stepDebug(child); + + for(; nd.hasNext(); nChild = nd.next()) { + ctx.thunk.accept(new SingleIterator<>(child)); + } + } else { + nChild = new Tree<>(new Node(Node.Type.RESULT, evaluate(child))); + + if(nChild != null) ctx.thunk.accept(new SingleIterator<>(nChild)); } - ITree toCoerce = ast.getChild(0); - ITree retVal = new Tree<>(toCoerce.getHead()); - Deque> children = new LinkedList<>(); + Node childNode = nChild.getHead(); + EvaluatorResult res = childNode.resultVal; - CoerceSteps curLevel = CoerceSteps.INTEGER; - - for(int i = 0; i < toCoerce.getChildrenCount(); i++) { - ITree child = toCoerce.getChild(i); - ITree nChild = null; + if(res.type == FLOAT) curLevel = CoerceSteps.FLOAT; - if(ctx.isDebug) { - Iterator> nd = stepDebug(child); + children.add(nChild); + } - for(; nd.hasNext(); nChild = nd.next()) { - ctx.thunk.accept(new SingleIterator<>(child)); - } - } else { - nChild = new Tree<>(new Node(Node.Type.RESULT, evaluate(child))); + for(ITree child : children) { + Node nd = child.getHead(); + EvaluatorResult res = nd.resultVal; - if(nChild != null) ctx.thunk.accept(new SingleIterator<>(nChild)); + switch(res.type) { + case INT: + if(curLevel == CoerceSteps.FLOAT) { + nd.resultVal = new EvaluatorResult(FLOAT, (double)res.intVal); } + default: + // Do nothing + break; + } - Node childNode = nChild.getHead(); - EvaluatorResult res = childNode.resultVal; + retVal.addChild(child); + } - if(res.type == FLOAT) curLevel = CoerceSteps.FLOAT; + return retVal; + case DICESCALAR: + EvaluatorResult opr = ast.getChild(0).getHead().resultVal; - children.add(nChild); - } + if(opr.type != INT) { + } - for(ITree child : children) { - Node nd = child.getHead(); - EvaluatorResult res = nd.resultVal; - - switch(res.type) { - case INT: - if(curLevel == CoerceSteps.FLOAT) { - nd.resultVal = new EvaluatorResult(FLOAT, (double)res.intVal); - } - default: - // Do nothing - break; - } + return new Tree<>(new Node(Node.Type.RESULT, + new EvaluatorResult(DICE, + new ScalarDie(opr.intVal)))); + case DICEFUDGE: + EvaluatorResult oprn = ast.getChild(0).getHead().resultVal; - retVal.addChild(child); - } + if(oprn.type != INT) { + } - return retVal; - default: - Errors.inst.printError(EK_EVAL_INVUNARY, ast.getHead().operatorType.toString()); - return new Tree<>(FAIL(ast)); + return new Tree<>(new Node(Node.Type.RESULT, + new EvaluatorResult(DICE, + new FudgeDie(oprn.intVal)))); + default: + Errors.inst.printError(EK_EVAL_INVUNARY, ast.getHead().operatorType.toString()); + return new Tree<>(FAIL(ast)); } } @@ -185,23 +205,23 @@ public class Evaluator { ITree right = ast.getChild(1); switch(binOp) { - case ADD: - case SUBTRACT: - case MULTIPLY: - case DIVIDE: - case IDIVIDE: - return evaluateMathBinary(binOp, - left.getHead().resultVal, right.getHead().resultVal, - ctx); - case DICEGROUP: - case DICECONCAT: - case DICELIST: - return evaluateDiceBinary(binOp, - left.getHead().resultVal, right.getHead().resultVal, - ctx); - default: - Errors.inst.printError(EK_EVAL_UNBIN, binOp.toString()); - return new Tree<>(FAIL(ast)); + case ADD: + case SUBTRACT: + case MULTIPLY: + case DIVIDE: + case IDIVIDE: + return evaluateMathBinary(binOp, + left.getHead().resultVal, right.getHead().resultVal, + ctx); + case DICEGROUP: + case DICECONCAT: + case DICELIST: + return evaluateDiceBinary(binOp, + left.getHead().resultVal, right.getHead().resultVal, + ctx); + default: + Errors.inst.printError(EK_EVAL_UNBIN, binOp.toString()); + return new Tree<>(FAIL(ast)); } } @@ -210,57 +230,57 @@ public class Evaluator { EvaluatorResult res = null; switch(op) { - case DICEGROUP: - if(left.type == DICE && !left.diceVal.isList) { - if(right.type == DICE && !right.diceVal.isList) { - res = new EvaluatorResult(DICE, - new SimpleDie(left.diceVal.scalar, right.diceVal.scalar)); - } else if (right.type == INT) { - res = new EvaluatorResult(DICE, new SimpleDie(left.diceVal.scalar, right.intVal)); - } else { - Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString()); - return new Tree<>(FAIL(right)); - } - } else if(left.type == INT) { - if(right.type == DICE && !right.diceVal.isList) { - res = new EvaluatorResult(DICE, new SimpleDie(left.intVal, right.diceVal.scalar)); - } else if (right.type == INT) { - res = new EvaluatorResult(DICE, new SimpleDie(left.intVal, right.intVal)); - } else { - Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString()); - return new Tree<>(FAIL(right)); - } + case DICEGROUP: + if(left.type == DICE && !left.diceVal.isList) { + if(right.type == DICE && !right.diceVal.isList) { + res = new EvaluatorResult(DICE, + new SimpleDie(left.diceVal.scalar, right.diceVal.scalar)); + } else if (right.type == INT) { + res = new EvaluatorResult(DICE, new SimpleDie(left.diceVal.scalar, right.intVal)); } else { - Errors.inst.printError(EK_EVAL_INVDGROUP, left.type.toString()); - return new Tree<>(FAIL(left)); - } - case DICECONCAT: - if(left.type != DICE || left.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString()); - return new Tree<>(FAIL(left)); - } else if(right.type != DICE || right.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString()); + Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString()); return new Tree<>(FAIL(right)); - } else { - res = new EvaluatorResult(DICE, - new CompoundDie(left.diceVal.scalar, right.diceVal.scalar)); } - break; - case DICELIST: - if(left.type != DICE || left.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString()); - return new Tree<>(FAIL(left)); - } else if(right.type != DICE || right.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString()); - return new Tree<>(FAIL(right)); + } else if(left.type == INT) { + if(right.type == DICE && !right.diceVal.isList) { + res = new EvaluatorResult(DICE, new SimpleDie(left.intVal, right.diceVal.scalar)); + } else if (right.type == INT) { + res = new EvaluatorResult(DICE, new SimpleDie(left.intVal, right.intVal)); } else { - res = new EvaluatorResult(DICE, - new SimpleDieList(left.diceVal.scalar, right.diceVal.scalar)); + Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString()); + return new Tree<>(FAIL(right)); } - break; - default: - Errors.inst.printError(EK_EVAL_UNDICE, op.toString()); - return new Tree<>(FAIL()); + } else { + Errors.inst.printError(EK_EVAL_INVDGROUP, left.type.toString()); + return new Tree<>(FAIL(left)); + } + case DICECONCAT: + if(left.type != DICE || left.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString()); + return new Tree<>(FAIL(left)); + } else if(right.type != DICE || right.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString()); + return new Tree<>(FAIL(right)); + } else { + res = new EvaluatorResult(DICE, + new CompoundDie(left.diceVal.scalar, right.diceVal.scalar)); + } + break; + case DICELIST: + if(left.type != DICE || left.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString()); + return new Tree<>(FAIL(left)); + } else if(right.type != DICE || right.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString()); + return new Tree<>(FAIL(right)); + } else { + res = new EvaluatorResult(DICE, + new SimpleDieList(left.diceVal.scalar, right.diceVal.scalar)); + } + break; + default: + Errors.inst.printError(EK_EVAL_UNDICE, op.toString()); + return new Tree<>(FAIL()); } return new Tree<>(new Node(Node.Type.RESULT, res)); @@ -296,103 +316,103 @@ public class Evaluator { EvaluatorResult res = null; switch(op) { - case ADD: - if(left.type == INT) { - res = new EvaluatorResult(INT, left.intVal + right.intVal); - } else if(left.type == DICE) { - if(left.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, left.toString()); - return new Tree<>(FAIL(left)); - } else if(right.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, right.toString()); - return new Tree<>(FAIL(right)); - } + case ADD: + if(left.type == INT) { + res = new EvaluatorResult(INT, left.intVal + right.intVal); + } else if(left.type == DICE) { + if(left.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, left.toString()); + return new Tree<>(FAIL(left)); + } else if(right.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, right.toString()); + return new Tree<>(FAIL(right)); + } - res = new EvaluatorResult(DICE, new MathDie(MathDie.MathOp.ADD, - left.diceVal.scalar, right.diceVal.scalar)); - } else { - res = new EvaluatorResult(FLOAT, left.floatVal + right.floatVal); + res = new EvaluatorResult(DICE, new MathDie(MathDie.MathOp.ADD, + left.diceVal.scalar, right.diceVal.scalar)); + } else { + res = new EvaluatorResult(FLOAT, left.floatVal + right.floatVal); + } + break; + case SUBTRACT: + if(left.type == INT) { + res = new EvaluatorResult(INT, left.intVal - right.intVal); + } else if(left.type == DICE) { + if(left.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, left.toString()); + return new Tree<>(FAIL(left)); + } else if(right.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, right.toString()); + return new Tree<>(FAIL(right)); } - break; - case SUBTRACT: - if(left.type == INT) { - res = new EvaluatorResult(INT, left.intVal - right.intVal); - } else if(left.type == DICE) { - if(left.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, left.toString()); - return new Tree<>(FAIL(left)); - } else if(right.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, right.toString()); - return new Tree<>(FAIL(right)); - } - res = new EvaluatorResult(DICE, new MathDie(MathDie.MathOp.SUBTRACT, - left.diceVal.scalar, right.diceVal.scalar)); - } else { - res = new EvaluatorResult(FLOAT, left.floatVal - right.floatVal); + res = new EvaluatorResult(DICE, new MathDie(MathDie.MathOp.SUBTRACT, + left.diceVal.scalar, right.diceVal.scalar)); + } else { + res = new EvaluatorResult(FLOAT, left.floatVal - right.floatVal); + } + break; + case MULTIPLY: + if(left.type == INT) { + res = new EvaluatorResult(INT, left.intVal * right.intVal); + } else if(left.type == DICE) { + if(left.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, left.toString()); + return new Tree<>(FAIL(left)); + } else if(right.diceVal.isList) { + Errors.inst.printError(EK_EVAL_INVDICE, right.toString()); + return new Tree<>(FAIL(right)); } - break; - case MULTIPLY: - if(left.type == INT) { - res = new EvaluatorResult(INT, left.intVal * right.intVal); - } else if(left.type == DICE) { - if(left.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, left.toString()); - return new Tree<>(FAIL(left)); - } else if(right.diceVal.isList) { - Errors.inst.printError(EK_EVAL_INVDICE, right.toString()); - return new Tree<>(FAIL(right)); - } - res = new EvaluatorResult(DICE, new MathDie(MathDie.MathOp.MULTIPLY, - left.diceVal.scalar, right.diceVal.scalar)); + res = new EvaluatorResult(DICE, new MathDie(MathDie.MathOp.MULTIPLY, + left.diceVal.scalar, right.diceVal.scalar)); + } else { + res = new EvaluatorResult(FLOAT, left.floatVal * right.floatVal); + } + break; + case DIVIDE: + if(left.type == INT) { + if(right.intVal == 0) { + Errors.inst.printError(EK_EVAL_DIVZERO); + res = new EvaluatorResult(FAILURE, right); } else { - res = new EvaluatorResult(FLOAT, left.floatVal * right.floatVal); + res = new EvaluatorResult(FLOAT, left.intVal / right.intVal); } - break; - case DIVIDE: - if(left.type == INT) { - if(right.intVal == 0) { - Errors.inst.printError(EK_EVAL_DIVZERO); - res = new EvaluatorResult(FAILURE, right); - } else { - res = new EvaluatorResult(FLOAT, left.intVal / right.intVal); - } - } else if(left.type == FLOAT) { - if(right.floatVal == 0) { - Errors.inst.printError(EK_EVAL_DIVZERO); - res = new EvaluatorResult(FAILURE, right); - } else { - res = new EvaluatorResult(FLOAT, left.floatVal / right.floatVal); - } + } else if(left.type == FLOAT) { + if(right.floatVal == 0) { + Errors.inst.printError(EK_EVAL_DIVZERO); + res = new EvaluatorResult(FAILURE, right); } else { - Errors.inst.printError(EK_EVAL_DIVDICE); - return new Tree<>(FAIL()); + res = new EvaluatorResult(FLOAT, left.floatVal / right.floatVal); } - break; - case IDIVIDE: - if(left.type == INT) { - if(right.intVal == 0) { - Errors.inst.printError(EK_EVAL_DIVZERO); - res = new EvaluatorResult(FAILURE, right); - } else { - res = new EvaluatorResult(INT, (int) (left.intVal / right.intVal)); - } - } else if(left.type == FLOAT) { - if(right.floatVal == 0) { - Errors.inst.printError(EK_EVAL_DIVZERO); - res = new EvaluatorResult(FAILURE, right); - } else { - res = new EvaluatorResult(INT, (int) (left.floatVal / right.floatVal)); - } + } else { + Errors.inst.printError(EK_EVAL_DIVDICE); + return new Tree<>(FAIL()); + } + break; + case IDIVIDE: + if(left.type == INT) { + if(right.intVal == 0) { + Errors.inst.printError(EK_EVAL_DIVZERO); + res = new EvaluatorResult(FAILURE, right); } else { - Errors.inst.printError(EK_EVAL_DIVDICE); - return new Tree<>(FAIL()); + res = new EvaluatorResult(INT, (int) (left.intVal / right.intVal)); } - break; - default: - Errors.inst.printError(EK_EVAL_UNMATH, op.toString()); + } else if(left.type == FLOAT) { + if(right.floatVal == 0) { + Errors.inst.printError(EK_EVAL_DIVZERO); + res = new EvaluatorResult(FAILURE, right); + } else { + res = new EvaluatorResult(INT, (int) (left.floatVal / right.floatVal)); + } + } else { + Errors.inst.printError(EK_EVAL_DIVDICE); return new Tree<>(FAIL()); + } + break; + default: + Errors.inst.printError(EK_EVAL_UNMATH, op.toString()); + return new Tree<>(FAIL()); } return new Tree<>(new Node(Node.Type.RESULT, res)); @@ -402,21 +422,21 @@ public class Evaluator { EvaluatorResult res = null; switch(tk.type) { - case INT_LIT: - res = new EvaluatorResult(INT, tk.intValue); - break; - case FLOAT_LIT: - res = new EvaluatorResult(FLOAT, tk.floatValue); - break; - case DICE_LIT: - res = new EvaluatorResult(DICE, tk.diceValue); - break; - case STRING_LIT: - res = new EvaluatorResult(STRING, eng.stringLits.get((int)(tk.intValue))); - break; - default: - Errors.inst.printError(EK_EVAL_UNTOK, tk.type.toString()); - res = new EvaluatorResult(FAILURE); + case INT_LIT: + res = new EvaluatorResult(INT, tk.intValue); + break; + case FLOAT_LIT: + res = new EvaluatorResult(FLOAT, tk.floatValue); + break; + case DICE_LIT: + res = new EvaluatorResult(DICE, tk.diceValue); + break; + case STRING_LIT: + res = new EvaluatorResult(STRING, eng.stringLits.get((int)(tk.intValue))); + break; + default: + Errors.inst.printError(EK_EVAL_UNTOK, tk.type.toString()); + res = new EvaluatorResult(FAILURE); } return new Tree<>(new Node(Node.Type.RESULT, res)); diff --git a/dice-lang/src/bjc/dicelang/Parser.java b/dice-lang/src/bjc/dicelang/Parser.java index 4733ced..db050c4 100644 --- a/dice-lang/src/bjc/dicelang/Parser.java +++ b/dice-lang/src/bjc/dicelang/Parser.java @@ -77,6 +77,8 @@ public class Parser { } break; case COERCE: + case DICESCALAR: + case DICEFUDGE: if(working.size() == 0) { Errors.inst.printError(EK_PARSE_UNOPERAND, tk.toString()); } else { diff --git a/dice-lang/src/bjc/dicelang/Token.java b/dice-lang/src/bjc/dicelang/Token.java index c022fe1..62755d2 100644 --- a/dice-lang/src/bjc/dicelang/Token.java +++ b/dice-lang/src/bjc/dicelang/Token.java @@ -15,21 +15,22 @@ public class Token { public static enum Type { // Natural tokens // These are produced from lexemes - ADD, SUBTRACT, + ADD, SUBTRACT, MULTIPLY, - DIVIDE, IDIVIDE, - INT_LIT, FLOAT_LIT, STRING_LIT, + DIVIDE, IDIVIDE, + INT_LIT, FLOAT_LIT, STRING_LIT, VREF, - DICE_LIT, DICEGROUP, DICECONCAT, DICELIST, - LET, BIND, COERCE, - OPAREN, CPAREN, - OBRACKET, CBRACKET, - OBRACE, CBRACE, + DICE_LIT, DICESCALAR, DICEFUDGE, + DICEGROUP, DICECONCAT, DICELIST, + LET, BIND, COERCE, + OPAREN, CPAREN, + OBRACKET, CBRACKET, + OBRACE, CBRACE, // Synthetic tokens // These are produced when needed - NIL, GROUPSEP, TOKGROUP, - TAGOP, TAGOPR + NIL, GROUPSEP, TOKGROUP, + TAGOP, TAGOPR } public final Type type; diff --git a/dice-lang/src/bjc/dicelang/Tokenizer.java b/dice-lang/src/bjc/dicelang/Tokenizer.java index 532a6a4..f13023c 100644 --- a/dice-lang/src/bjc/dicelang/Tokenizer.java +++ b/dice-lang/src/bjc/dicelang/Tokenizer.java @@ -29,6 +29,8 @@ public class Tokenizer { litTokens.put("*", MULTIPLY); litTokens.put("/", DIVIDE); litTokens.put("//", IDIVIDE); + litTokens.put("sd", DICESCALAR); + litTokens.put("df", DICEFUDGE); litTokens.put("dg", DICEGROUP); litTokens.put("dc", DICECONCAT); litTokens.put("dl", DICELIST); diff --git a/dice-lang/src/bjc/dicelang/dice/FudgeDie.java b/dice-lang/src/bjc/dicelang/dice/FudgeDie.java index ca4fb73..554c7ff 100644 --- a/dice-lang/src/bjc/dicelang/dice/FudgeDie.java +++ b/dice-lang/src/bjc/dicelang/dice/FudgeDie.java @@ -7,6 +7,10 @@ public class FudgeDie implements Die { numDice = new ScalarDie(nDice); } + public FudgeDie(Die nDice) { + numDice = nDice; + } + public boolean canOptimize() { return numDice.canOptimize() && numDice.optimize() == 0; } @@ -34,4 +38,4 @@ public class FudgeDie implements Die { public String toString() { return numDice + "dF"; } -} \ No newline at end of file +} -- cgit v1.2.3