init

Reversi/GameTree.java

@@ -0,0 +1,75 @@
+package reversi.model;
+
+/**
+ * Class for a GameTree.
+ */
+public class GameTree {
+
+    /**
+     * Root gamenode of the gametree.
+     */
+    private GameNode root;
+
+    /**
+     * Constructs a new gametree.
+     *
+     * @param board of the root node
+     * @param level depth of the tree
+     */
+    GameTree(final Reversi board, final int level) {
+        this.root = new GameNode(new Field(0, 0), board.clone());
+        fillTree(root, level);
+        generateScores(root);
+    }
+
+    /**
+     *
+     * @return Root of the gametree.
+     */
+    public final GameNode getRoot() {
+        return root;
+    }
+
+    /**
+     * Fill the Tree with nodes.
+     *
+     * @param node Node to fill (in most cases root gamenode)
+     * @param depth depth of the tree (level)
+     */
+    private void fillTree(final GameNode node, final int depth) {
+        if (depth > 0) {
+            node.fillNode();
+
+            for (GameNode n : node.getChildren()) {
+                fillTree(n, (depth - 1));
+            }
+        }
+    }
+
+    /**
+     * Generates and sets the score of a Gamenode.
+     *
+     * @param node Gamenode to set
+     */
+    public final void generateScores(final GameNode node) {
+        Reversi currentBoard = node.getState();
+
+        if (!node.hasChild()) {
+            node.setScore(currentBoard.score());
+        } else {
+            double score;
+            score = currentBoard.score();
+
+            for (GameNode child : node.getChildren()) {
+                generateScores(child);
+            }
+
+            if (!currentBoard.next().getType()) {
+                score += node.getChildrensHighestScore().getScore();
+            } else {
+                score += node.getChildrensLowestScore().getScore();
+            }
+            node.setScore(score);
+        }
+    }
+}