summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/jrummikub/model/StoneSet.java57
-rw-r--r--src/jrummikub/model/Table.java2
-rw-r--r--test/jrummikub/control/RoundControlTest.java11
-rw-r--r--test/jrummikub/model/GameStateTest.java1
-rw-r--r--test/jrummikub/model/StoneSetTest.java134
5 files changed, 147 insertions, 58 deletions
diff --git a/src/jrummikub/model/StoneSet.java b/src/jrummikub/model/StoneSet.java
index b798ad0..2fd8e96 100644
--- a/src/jrummikub/model/StoneSet.java
+++ b/src/jrummikub/model/StoneSet.java
@@ -52,7 +52,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
* @return true when the set is valid according to the rules
*/
public boolean isValid() {
- return classify() != INVALID;
+ return classify().getFirst() != INVALID;
}
/**
@@ -61,10 +61,11 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
*
* @return GROUP or RUN for valid sets, INVALID otherwise
*/
- public Type classify() {
+ // TODO: Vernünftige Werte Returnen
+ public Pair<Type, Integer> classify() {
// TODO: extend this for score calculation (release 2...)
if (stones.size() < 3) {
- return INVALID;
+ return new Pair<Type, Integer>(INVALID, 0);
}
int nonJoker1 = -1, nonJoker2 = -1;
for (int i = 0; i < stones.size(); i++) {
@@ -75,18 +76,36 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
nonJoker1 = i;
}
if (nonJoker2 == -1) {
- return GROUP;
+ // Z first
+ if (nonJoker1 == 0 && stones.get(nonJoker1).getValue() < 12) {
+ int origValue = stones.get(nonJoker1).getValue();
+ int value = 0;
+ for (int i = 0; i < stones.size(); i++) {
+ value += origValue + i;
+ }
+ return new Pair<Type, Integer>(RUN, value);
+ } else {
+ int value = stones.get(nonJoker1).getValue() * stones.size();
+ return new Pair<Type, Integer>(GROUP, value);
+ }
}
+
// is run
if (stones.get(nonJoker1).getColor() == stones.get(nonJoker2)
.getColor()) {
- return isValidRun(nonJoker1) ? RUN : INVALID;
+ if (isValidRun(nonJoker1) > 0) {
+ return new Pair<Type, Integer>(RUN, isValidRun(nonJoker1));
+ }
+ return new Pair<Type, Integer>(INVALID, 0);
}
// is group
else {
- return isValidGroup(stones.get(nonJoker1).getValue()) ? GROUP
- : INVALID;
+ if (isValidGroup(stones.get(nonJoker1).getValue()) > 0) {
+ return new Pair<Type, Integer>(GROUP, isValidGroup(stones.get(
+ nonJoker1).getValue()));
+ }
+ return new Pair<Type, Integer>(INVALID, 0);
}
}
@@ -96,13 +115,13 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
* @param referencePosition
* position of stone used as reference (any non-joker stone)
*/
- private boolean isValidRun(int referencePosition) {
+ private int isValidRun(int referencePosition) {
StoneColor runColor = stones.get(referencePosition).getColor();
int startValue = stones.get(referencePosition).getValue()
- referencePosition;
int endValue = startValue + stones.size() - 1;
if (startValue < 1 || endValue > 13) {
- return false;
+ return 0;
}
for (int i = 0; i < stones.size(); i++) {
if (stones.get(i).isJoker()) {
@@ -110,21 +129,25 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
}
if (stones.get(i).getColor() != runColor) {
// warum macht er das nicht?
- return false;
+ return 0;
}
if (stones.get(i).getValue() != i + startValue) {
- return false;
+ return 0;
}
}
- return true;
+ int value = 0;
+ for (int i = 0; i < stones.size(); i++) {
+ value += startValue + i;
+ }
+ return value;
}
/**
* Test for rule conflict within the StoneSet, assuming we have a group
*/
- private boolean isValidGroup(int value) {
+ private int isValidGroup(int value) {
if (stones.size() > 4) {
- return false;
+ return 0;
}
Set<StoneColor> seenColors = new HashSet<StoneColor>();
for (Stone i : stones) {
@@ -132,15 +155,15 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
continue;
}
if (i.getValue() != value) {
- return false;
+ return 0;
}
if (seenColors.contains(i.getColor())) {
- return false;
+ return 0;
} else {
seenColors.add(i.getColor());
}
}
- return true;
+ return value * stones.size();
}
/**
diff --git a/src/jrummikub/model/Table.java b/src/jrummikub/model/Table.java
index f134975..a3e25eb 100644
--- a/src/jrummikub/model/Table.java
+++ b/src/jrummikub/model/Table.java
@@ -79,7 +79,7 @@ public class Table extends StoneTray<StoneSet> implements ITable {
StoneSet leftSet = firstSplit.getFirst();
StoneSet rightSet = secondSplit.getSecond();
- if (set.classify() == StoneSet.Type.RUN) {
+ if (set.classify().getFirst() == StoneSet.Type.RUN) {
Position leftPosition, rightPosition;
leftPosition = setPosition;
rightPosition = new Position(setPosition.getX() + stonePosition + 1,
diff --git a/test/jrummikub/control/RoundControlTest.java b/test/jrummikub/control/RoundControlTest.java
index 6c8dffe..3e610e3 100644
--- a/test/jrummikub/control/RoundControlTest.java
+++ b/test/jrummikub/control/RoundControlTest.java
@@ -91,6 +91,17 @@ public class RoundControlTest {
view.getTablePanel().rightPlayerName = null;
view.displayStartTurnPanel = false;
}
+
+ /** */
+ @Test
+ public void playerCameOutCorrectly(){
+ MockTable oldTable = new MockTable();
+ MockTable newTable = new MockTable();
+ Stone blueTen = new Stone(10, BLUE);
+ Stone redTen = new Stone(10, RED);
+ Stone blackTen = new Stone(10, BLACK);
+
+ }
/** */
@Test
diff --git a/test/jrummikub/model/GameStateTest.java b/test/jrummikub/model/GameStateTest.java
index 5681904..5a55aef 100644
--- a/test/jrummikub/model/GameStateTest.java
+++ b/test/jrummikub/model/GameStateTest.java
@@ -31,4 +31,5 @@ public class GameStateTest {
testGame.nextPlayer();
assertSame(Color.red, testGame.getActivePlayer().getColor());
}
+
}
diff --git a/test/jrummikub/model/StoneSetTest.java b/test/jrummikub/model/StoneSetTest.java
index e2962d4..4b83c94 100644
--- a/test/jrummikub/model/StoneSetTest.java
+++ b/test/jrummikub/model/StoneSetTest.java
@@ -16,92 +16,146 @@ import static org.junit.Assert.*;
*/
public class StoneSetTest {
- private void assertSet(StoneSet.Type expectedType, List<Stone> stones) {
+ private void assertSet(StoneSet.Type expectedType, Integer expectedValue,
+ List<Stone> stones) {
StoneSet set = new StoneSet(stones);
- assertSame(expectedType, set.classify());
+ assertSame(expectedType, set.classify().getFirst());
+ assertEquals(expectedValue, set.classify().getSecond());
}
- // valid
+ // valid+point count
/** */
@Test
public void doubleJoker() {
- assertSet(GROUP,
- Arrays.asList(new Stone(RED), new Stone(BLACK), new Stone(1, BLACK)));
+ // 3 Stones
+ // JJZ
+ assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(BLACK),
+ new Stone(1, BLACK)));
+ // JZJ
+ assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
+ new Stone(BLACK)));
+ // ZJJ
+ assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
+ new Stone(BLACK)));
+ // 4 Stones
+ // JJZZ
+ assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(BLACK),
+ new Stone(1, BLACK), new Stone(1, RED)));
+ assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(BLACK),
+ new Stone(3, RED), new Stone(4, RED)));
+ // ZZJJ
+ assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
+ new Stone(BLACK), new Stone(RED)));
+ assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
+ new Stone(1, BLACK), new Stone(BLACK), new Stone(RED)));
+ // ZJZJ
+ assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
+ new Stone(1, BLACK), new Stone(RED)));
+ assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED),
+ new Stone(3, RED), new Stone(BLACK)));
+ // JZJZ
+ assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
+ new Stone(BLACK), new Stone(1, RED)));
+ assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(2, RED),
+ new Stone(BLACK), new Stone(4, RED)));
+ // JZZJ
+ assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
+ new Stone(1, RED), new Stone(BLACK)));
+ assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(2, RED),
+ new Stone(3, RED), new Stone(BLACK)));
+ // ZJJZ
+ assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
+ new Stone(RED), new Stone(1, BLACK)));
+ assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED),
+ new Stone(BLACK), new Stone(4, RED)));
}
/** */
@Test
public void groups() {
- assertSet(GROUP, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK),
- new Stone(1, BLUE)));
- assertSet(GROUP, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK),
- new Stone(1, BLUE), new Stone(1, ORANGE)));
+ assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
+ new Stone(1, BLACK), new Stone(1, BLUE)));
+ assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
+ new Stone(1, BLACK), new Stone(1, BLUE), new Stone(1, ORANGE)));
}
/** */
@Test
public void runs() {
- assertSet(RUN,
- Arrays.asList(new Stone(1, RED), new Stone(2, RED), new Stone(3, RED)));
- assertSet(RUN, Arrays.asList(new Stone(4, BLUE), new Stone(5, BLUE),
- new Stone(6, BLUE)));
+ assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
+ new Stone(3, RED)));
+ assertSet(RUN, 22, Arrays.asList(new Stone(4, BLUE), new Stone(5, BLUE),
+ new Stone(6, BLUE), new Stone(7, BLUE)));
}
/** */
@Test
public void singleJoker() {
- assertSet(GROUP,
- Arrays.asList(new Stone(1, RED), new Stone(1, BLACK), new Stone(RED)));
- assertSet(RUN,
- Arrays.asList(new Stone(2, RED), new Stone(3, RED), new Stone(BLACK)));
+ // ZJZ
+ assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
+ new Stone(1, BLACK)));
+ assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
+ new Stone(3, RED)));
+ // JZZ
+ assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, RED),
+ new Stone(1, BLACK)));
+ assertSet(RUN, 6, Arrays.asList(new Stone(RED), new Stone(2, RED),
+ new Stone(3, RED)));
+ // ZZJ
+ assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
+ new Stone(1, BLACK), new Stone(BLACK)));
+ assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
+ new Stone(RED)));
}
// invalid
/** */
@Test
public void outOfBounds() {
- assertSet(INVALID, Arrays.asList(new Stone(RED), new Stone(1, RED),
+ assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(1, RED),
new Stone(2, RED)));
- assertSet(INVALID, Arrays.asList(new Stone(12, RED),
- new Stone(13, RED), new Stone(RED)));
- assertSet(INVALID, Arrays.asList(new Stone(RED), new Stone(BLACK),
+ assertSet(INVALID, 0, Arrays.asList(new Stone(12, RED), new Stone(13,
+ RED), new Stone(RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(BLACK),
new Stone(1, RED), new Stone(2, RED)));
}
/** */
@Test
public void sameColor() {
- assertSet(INVALID,
- Arrays.asList(new Stone(1, RED), new Stone(1, RED), new Stone(1, BLUE)));
- assertSet(INVALID, Arrays.asList(new Stone(1, RED), new Stone(1, BLUE),
- new Stone(1, BLACK), new Stone(1, ORANGE), new Stone(RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED),
+ new Stone(1, RED), new Stone(1, BLUE)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
+ BLUE), new Stone(1, BLACK), new Stone(1, ORANGE),
+ new Stone(RED)));
}
/** */
@Test
public void incorrectOrder() {
- assertSet(INVALID,
- Arrays.asList(new Stone(4, RED), new Stone(6, RED), new Stone(5, RED)));
- assertSet(INVALID,
- Arrays.asList(new Stone(4, RED), new Stone(6, RED), new Stone(RED)));
- assertSet(INVALID,
- Arrays.asList(new Stone(4, RED), new Stone(RED), new Stone(5, RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
+ new Stone(6, RED), new Stone(5, RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
+ new Stone(6, RED), new Stone(RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED), new Stone(RED),
+ new Stone(5, RED)));
}
/** */
@Test
public void otherInvalid() {
- assertSet(INVALID,
- Arrays.asList(new Stone(4, RED), new Stone(5, RED), new Stone(7, RED)));
- assertSet(INVALID,
- Arrays.asList(new Stone(4, RED), new Stone(5, BLUE), new Stone(6, RED)));
- assertSet(INVALID, Arrays.asList(new Stone(4, RED), new Stone(5, RED)));
- assertSet(INVALID,
- Arrays.asList(new Stone(4, BLUE), new Stone(5, RED), new Stone(6, RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
+ new Stone(5, RED), new Stone(7, RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED), new Stone(5,
+ BLUE), new Stone(6, RED)));
+ assertSet(INVALID, 0,
+ Arrays.asList(new Stone(4, RED), new Stone(5, RED)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(4, BLUE), new Stone(5,
+ RED), new Stone(6, RED)));
// Regression test:
- assertSet(INVALID, Arrays.asList(new Stone(12, ORANGE), new Stone(12,
- BLACK), new Stone(7, BLUE)));
+ assertSet(INVALID, 0, Arrays.asList(new Stone(12, ORANGE), new Stone(
+ 12, BLACK), new Stone(7, BLUE)));
}
// invalid Split
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 07:41:08 +0100