/// <summary>
    /// Builds the tree
    /// </summary>
    /// <param name="boardConfiguration">current board configuration</param>
    /// <returns>tree</returns>
    MinimaxTree <Configuration> BuildTree(
        Configuration boardConfiguration)
    {
        // build tree to appropriate depth
        MinimaxTree <Configuration> tree =
            new MinimaxTree <Configuration>(boardConfiguration);

        nodeList.Clear();
        nodeList.AddLast(tree.Root);
        while (nodeList.Count > 0)
        {
            MinimaxTreeNode <Configuration> currentNode =
                nodeList.First.Value;
            nodeList.RemoveFirst();
            List <Configuration> children =
                GetNextConfigurations(currentNode.Value);
            foreach (Configuration child in children)
            {
                // STUDENTS: only add to tree if within search depth

                MinimaxTreeNode <Configuration> childNode =
                    new MinimaxTreeNode <Configuration>(
                        child, currentNode);
                if (Level(childNode) <= searchDepth)
                {
                    tree.AddNode(childNode);
                    nodeList.AddLast(childNode);
                }
            }
        }
        return(tree);
    }
Example #2
0
 /// <summary>
 /// Handles the TakeTurn event
 /// </summary>
 /// <param name="player">whose turn it is</param>
 /// <param name="boardConfiguration">current board configuration</param>
 void HandleTakeTurnEvent(PlayerName player, Configuration boardConfiguration)
 {
     // only take turn if it's our turn
     if (player == myName)
     {
         tree = BuildTree(boardConfiguration);
         thinkingTimer.Run();
     }
 }
Example #3
0
    /// <summary>
    /// Builds the tree
    /// </summary>
    /// <param name="boardConfiguration">current board configuration</param>
    /// <returns>tree</returns>
    MinimaxTree <Configuration> BuildTree(
        Configuration boardConfiguration)
    {
        // build tree to appropriate depth
        MinimaxTree <Configuration> tree =
            new MinimaxTree <Configuration>(boardConfiguration);

        // clear the list of nodes
        nodeList.Clear();

        // add the root as the initial node
        nodeList.AddLast(tree.Root);

        // iterate over all nodes while there are nodes to process
        while (nodeList.Count > 0)
        {
            // get the currentNode
            MinimaxTreeNode <Configuration> currentNode =
                nodeList.First.Value;

            // remove it from the list of nodes (to avoid processing it again)
            nodeList.RemoveFirst();

            // Get all possible configurations that might result from
            // from the one for the current node (as long as they
            // contain bears).
            // These configurations represent possible child nodes of this node.
            List <Configuration> possibleConfigurations =
                GetNextConfigurations(currentNode.Value);

            // get the depth of this node
            int childDepth = getChildDepth(currentNode);

            // if we are still within the search depth
            if (childDepth <= searchDepth)
            {
                // iterate over all possible configurations where
                // bins contain bears
                foreach (Configuration configuration in possibleConfigurations)
                {
                    // create a new child node with this configuration
                    MinimaxTreeNode <Configuration> childNode =
                        new MinimaxTreeNode <Configuration>(
                            configuration, currentNode);

                    // add the child node to the tree
                    tree.AddNode(childNode);

                    // and add it to the node list
                    nodeList.AddLast(childNode);
                }
            }
        }
        return(tree);
    }
Example #4
0
    void Start()
    {
        // build and mark the tree with minimax scores
        MinimaxTree <char> tree = BuildTree();

        // print out tree
        Debug.Log("Root item value: " + tree.Root.Value);
        IList <MinimaxTreeNode <char> > children = tree.Root.Children;

        if (children.Count > 0)
        {
            foreach (MinimaxTreeNode <char> child in children)
            {
                Debug.Log("Node item value: " + child.Value + ", Node Parent: " + child.Parent.Value);
                printChildren(child);
            }
        }

        // sets whether we are maximizing
        bool maximizing = false;

        Minimax(tree.Root, maximizing);

        // find child node with maximum score
        MinimaxTreeNode <char> maxChildNode = children[0];

        for (int i = 1; i < children.Count; i++)
        {
            if (maximizing)
            {
                if (children[i].MinimaxScore > maxChildNode.MinimaxScore)
                {
                    maxChildNode = children[i];
                }
            }
            else
            {
                if (children[i].MinimaxScore < maxChildNode.MinimaxScore)
                {
                    maxChildNode = children[i];
                }
            }
        }

        Debug.Log("Best move is to node: " + maxChildNode.Value);
    }
Example #5
0
    static MinimaxTree <char> BuildTree()
    {
        MinimaxTree <char>     tree  = new MinimaxTree <char>('A');
        MinimaxTreeNode <char> bNode = new MinimaxTreeNode <char>('B', tree.Root);

        tree.AddNode(bNode);
        MinimaxTreeNode <char> cNode = new MinimaxTreeNode <char>('C', tree.Root);

        tree.AddNode(cNode);
        MinimaxTreeNode <char> dNode = new MinimaxTreeNode <char>('D', tree.Root);

        tree.AddNode(dNode);
        MinimaxTreeNode <char> eNode = new MinimaxTreeNode <char>('E', bNode);

        tree.AddNode(eNode);
        MinimaxTreeNode <char> fNode = new MinimaxTreeNode <char>('F', bNode);

        tree.AddNode(fNode);
        MinimaxTreeNode <char> gNode = new MinimaxTreeNode <char>('G', bNode);

        tree.AddNode(gNode);
        MinimaxTreeNode <char> hNode = new MinimaxTreeNode <char>('H', cNode);

        tree.AddNode(hNode);
        MinimaxTreeNode <char> iNode = new MinimaxTreeNode <char>('I', cNode);

        tree.AddNode(iNode);
        MinimaxTreeNode <char> jNode = new MinimaxTreeNode <char>('J', dNode);

        tree.AddNode(jNode);
        MinimaxTreeNode <char> kNode = new MinimaxTreeNode <char>('K', dNode);

        tree.AddNode(kNode);
        MinimaxTreeNode <char> lNode = new MinimaxTreeNode <char>('L', eNode);

        tree.AddNode(lNode);
        MinimaxTreeNode <char> mNode = new MinimaxTreeNode <char>('M', eNode);

        tree.AddNode(mNode);
        MinimaxTreeNode <char> nNode = new MinimaxTreeNode <char>('N', fNode);

        tree.AddNode(nNode);
        MinimaxTreeNode <char> oNode = new MinimaxTreeNode <char>('O', fNode);

        tree.AddNode(oNode);
        MinimaxTreeNode <char> pNode = new MinimaxTreeNode <char>('P', gNode);

        tree.AddNode(pNode);
        MinimaxTreeNode <char> qNode = new MinimaxTreeNode <char>('Q', gNode);

        tree.AddNode(qNode);
        MinimaxTreeNode <char> rNode = new MinimaxTreeNode <char>('R', hNode);

        tree.AddNode(rNode);
        MinimaxTreeNode <char> sNode = new MinimaxTreeNode <char>('S', hNode);

        tree.AddNode(sNode);
        MinimaxTreeNode <char> tNode = new MinimaxTreeNode <char>('T', iNode);

        tree.AddNode(tNode);
        MinimaxTreeNode <char> uNode = new MinimaxTreeNode <char>('U', iNode);

        tree.AddNode(uNode);
        MinimaxTreeNode <char> vNode = new MinimaxTreeNode <char>('V', jNode);

        tree.AddNode(vNode);
        MinimaxTreeNode <char> wNode = new MinimaxTreeNode <char>('W', jNode);

        tree.AddNode(wNode);
        MinimaxTreeNode <char> xNode = new MinimaxTreeNode <char>('X', kNode);

        tree.AddNode(xNode);
        MinimaxTreeNode <char> yNode = new MinimaxTreeNode <char>('Y', kNode);

        tree.AddNode(yNode);
        return(tree);
    }