Android Open Source - Turn-of-War Node

From Project

Back to project page Turn-of-War.
License

The source code is released under:
Apache License
If you think the Android project Turn-of-War listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
Java Source Code

/* This file is part of Dragon Wars.
 *//from  w w w  .j a v a  2s . c o  m
 * Dragon Wars is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Dragon Wars is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Dragon Wars. If not, see <http://www.gnu.org/licenses/>.
 */

package uk.co.fuuzetsu.turnofwar.engine.GoalArbitration;

import java.util.ArrayList;
import java.util.List;

import android.util.Log;

public final class Node {
    private AtomicAction nodeAction;
    private Node nodeParent;
    private List<Node> children;
    private int min = -1, max = -1;
    private float minValue = Float.MAX_VALUE; // Min child node value
    private float maxValue = Float.MIN_VALUE; // Max child node value
    private int nodeDepth;
    private float currentValue;
    private static int size = 1; // Tree size thus far
    private static int maxSize = 300; // Max tree size

    public Node(final Node parent, final int depth, final float currentvalue,
                final AtomicAction action) {
        nodeAction = action;
        nodeParent = parent;
        nodeDepth = depth;
        currentValue = currentvalue;
        children = new ArrayList<Node>();
    }

    public List<AtomicAction> getActions() {
        List<AtomicAction> nodes = new ArrayList<AtomicAction>();

        // explore tree recursively up to a defined depth
        for (Node child : children) {
            nodes.addAll(child.getActions());
        }

        if (children.size() == 0) {
            if (this.nodeAction != null) {
                nodes.add(this.nodeAction);
            } else {
                Log.d("Node", "The only action we had was null.");
            }
        }

        return nodes;
    }

    public List<Node> getTerminals() {
        List<Node> nodes = new ArrayList<Node>();

        // explore tree recursively up to a defined depth
        for (Node child : children) {
            nodes.addAll((List<Node>) child.getTerminals());
        }

        if (children.size() == 0) {
            nodes.add(this);
        }

        return nodes;
    }

    // collapse tree from bottom to the base node
    public float Collapse() {
        float value = currentValue;

        if (getMiniMax()) {
            for (Node child : children) {
                value += child.Collapse();
                size--;
            }
        } else {
            for (Node child : children) {
                value += child.Collapse();
                size--;
            }
        }

        children.clear();
        return value;
    }

    public void AddChildNode(final float value, final AtomicAction action) {
        children.add(new Node(this, nodeDepth + 1, value, action));

        if (children.size() > 0) {
            if (value < minValue) {
                minValue = value;
                min = children.size();
            } else if (value > maxValue) {
                maxValue = value;
                max = children.size();
            }
        }

        size++;
    }

    public float getTotalValue() {
        float totalValue = currentValue;

        // recursively calculates current node value;
        if (nodeParent == null) {
            return getCurrentValue();
        }

        if (nodeDepth > 0) {
            totalValue += nodeParent.getTotalValue();
        }

        return totalValue;
    }

    public float getCurrentValue() {
        return currentValue;
    }

    public boolean getMiniMax() {
        return nodeDepth % 2 == 0;
    }

    public void setSize(final int newSize) {
        size = newSize;
    }

    public int getSize() {
        return size;
    }

    public boolean isFull() {
        return maxSize <= size;
    }
}
Java Source Code List
