1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
package bjc.dicelang;
import static bjc.dicelang.DiceExpressionType.ADD;
import static bjc.dicelang.DiceExpressionType.DIVIDE;
import static bjc.dicelang.DiceExpressionType.MULTIPLY;
import static bjc.dicelang.DiceExpressionType.SUBTRACT;
/**
* Build a dice expression piece by piece
*
* @author ben
*
*/
public class DiceExpressionBuilder {
/**
* The dice expression we are building
*/
private IDiceExpression baking;
/**
* Build a dice expression from a seed dice expression
*
* @param seed
* The dice expression to use as a seed
*/
public DiceExpressionBuilder(IDiceExpression seed) {
baking = seed;
}
/**
* Build a dice expression from a seed dice
*
* @param nSides
* The number of sides in the dice
* @param nDice
* The number of dice in the group
*/
public DiceExpressionBuilder(int nSides, int nDice) {
baking = new ComplexDice(nSides, nDice);
}
/**
* Add a term to this dice expression
*
* @param exp
* The expression to use on the left
* @return A new expression adding the two dice
*/
public DiceExpressionBuilder add(IDiceExpression exp) {
baking = new OperatorDiceExpression(baking, exp, ADD);
return this;
}
/**
* Add a scalar to this dice
*
* @param num
* The scalar to add to the dice
* @return A dice expression adding a scalar to this
*/
public DiceExpressionBuilder add(int num) {
baking = new ScalarDiceExpression(baking, num, ADD);
return this;
}
/**
* Bake the expression being built to completion
*
* @return A usable dice expression
*/
public IDiceExpression bake() {
return baking;
}
/**
* Divide a term from dice expression
*
* @param exp
* The expression to use on the left
* @return A new expression dividing the two dice
*/
public DiceExpressionBuilder divide(IDiceExpression exp) {
baking = new OperatorDiceExpression(baking, exp, DIVIDE);
return this;
}
/**
* Divide a scalar from this dice
*
* @param num
* The scalar to add to the dice
* @return A dice expression dividing a scalar from this
*/
public DiceExpressionBuilder divide(int num) {
baking = new ScalarDiceExpression(baking, num, DIVIDE);
return this;
}
/**
* Multiply a term by this dice expression
*
* @param exp
* The expression to use on the left
* @return A new expression multiplying the two dice
*/
public DiceExpressionBuilder multiply(IDiceExpression exp) {
baking = new OperatorDiceExpression(baking, exp, MULTIPLY);
return this;
}
/**
* Multiply a scalar by this dice
*
* @param num
* The scalar to multiply to the dice
* @return A dice expression multiplying a scalar to this
*/
public DiceExpressionBuilder multiply(int num) {
baking = new ScalarDiceExpression(baking, num, MULTIPLY);
return this;
}
/**
* Add a term to this dice expression
*
* @param exp
* The expression to use on the left
* @return A new expression adding the two dice
*/
public DiceExpressionBuilder subtract(IDiceExpression exp) {
baking = new OperatorDiceExpression(baking, exp, SUBTRACT);
return this;
}
/**
* Add a scalar to this dice
*
* @param num
* The scalar to add to the dice
* @return A dice expression adding a scalar to this
*/
public DiceExpressionBuilder subtract(int num) {
baking = new ScalarDiceExpression(baking, num, SUBTRACT);
return this;
}
}
|
