Пример #1
0
 public Solution copy()
 {
     double []newArray = new double[m_card];
     Array.Copy(m_data, 0, newArray, 0, m_card);
     Solution s = new Solution(newArray, this.m_state);
     s.m_through = this.m_through;
     return s;
 }
Пример #2
0
    public void add(Solution a_element)
    {
        //Additions are (asc) ordered by the value of the first element of the array.
        bool here = false;
        int i = 0;
        while(!here && i < m_members.Count)
        {
            Solution m = m_members[i];

            if(a_element.m_data[0] < m.m_data[0])
            {
                here = true;
                m_members.Insert(i,a_element);
            }
            ++i;
        }

        if(!here)
        {   //add at the end:
            m_members.Add(a_element);
        }

    }
Пример #3
0
        public bool add(Solution a_sol)
        {
            //Check if the new entry is dominated by any in the set:

            bool dominated = false;
            bool dominatesAny = false;
            bool crowded = false;
            int i = 0;
            while (!dominated && i < m_members.size())
            {
                Solution member = m_members.get(i);
                int dom = Utils.dominates(member.m_data, a_sol.m_data);

                //if(dom == -1)
                if (dom == -1)
                {
                    //if(crowded)
                    //  System.out.println("OUT ["+m_members.size()+"]");

                    dominated = true;
                }
                else if (dom == 1)
                {
                    //This one is dominated. It must be out.
                    m_members.remove(i);
                    m_hvClean = false;
                    dominatesAny = true;
                    //And keep the index in place:
                    --i;
                }
                else if (dom == 2)    //Use this line to allow any distance between points in pareto.
                //}else if(dom == 2 || crowded) //Use this line to avoid crowded fronts (min. distance: EPSILON).
                {
                    //There is another identical member in the set. Do NOT include:
                    return false;
                }
                else if (dom == 0)
                {
                    //crowded |= Utils.crowded(member.m_data, a_sol.m_data, EPSILON);
                }
                ++i;
            }

            if (dominatesAny)
                crowded = false;

            if (!dominated && !crowded)
            {
                /*double[] newOne = new double[a_candidate.length];
                System.arraycopy(a_candidate, 0, newOne, 0, a_candidate.length);
                Solution newSol = new Solution(newOne);    */
                //Helpfunctions.Instance.logg("Yes added sol:" + a_sol.m_data[0] + ", " + a_sol.m_data[1] + ", " + a_sol.m_data[2]);
                //a_sol.m_state.printLastTurnActions();
                m_members.add(a_sol);
                m_hvClean = false;
                return true;
            }
            else
            {
                //Helpfunctions.Instance.logg("No added sol:" + a_sol.m_data[0] + ", " + a_sol.m_data[1]);               
            }

            return false;
        }
Пример #4
0
    //public void advance(Playfield st, int action)
    //{
    //    bool gameOver = false;
    //    for(int singleAction = 0; !gameOver && singleAction < ParetoMCTSParameters.MACRO_ACTION_LENGTH; ++singleAction)
    //    {
    //        //((ParetoMCTSPlayer)m_player).m_heightMap[(int)st.getShip().s.x][(int)st.getShip().s.y]++;
    //        st.tick(action);
    //        NEXT_TICKS++;
    //        gameOver = st.isEnded();
    //    }
    //}


    //public bool finishRollout(Game rollerState, int depth, int action)
    //{
    //    if(depth >= ParetoMCTSParameters.ROLLOUT_DEPTH)      //rollout end condition.
    //        return true;

    //    if(action == -1)                           //end
    //        return true;

    //    if(rollerState.isEnded())               //end of game
    //    {
    //        //Console.WriteLine("End Reached!");
    //        return true;
    //    }

    //    return false;
    //}

    public void backUp(double[] result, Solution sol, bool Added, int cI) {

        /*nVisits++;
        Added = pa.Add(result);
        int comingFrom = cI;

        for(int i = 0; i < result.Length; ++i)
            totValue[i] += result[i];      */

        //for(ParetoTreeNode pn : m_runList)
        int comingFrom = -1;
        int numNodes = m_runList.Count;
        for(int i = 0; i < numNodes; ++i)
        {
            ParetoTreeNode pn = m_runList[i];
            //Helpfunctions.Instance.logg("node: " + pn.parent.nodeNum + ", children exhasuted: " + pn.parent.numExhaustedChildren + "/" + pn.parent.children.Length);

            if (pn.isTerminal || (pn.children != null && pn.numExhaustedChildren == pn.children.Length))
            {
                pn.isExhausted = true;
                if (pn.parent != null)
                {
                    pn.parent.numExhaustedChildren++;
                }
            }

            pn.nVisits++;

            if(Added)
                Added = pn.pa.add(sol);

            for(int j = 0; j < result.Length; ++j)
                pn.totValue[j] += result[j];

            if(i+1 < numNodes)
            {
                //ParetoTreeNode parentNode = m_runList.get(i+1);
                //parentNode.m_childCount[pn.childIndex]++; //for Nsa in one of the tree policies (see TransParetoTreePolicy).
                comingFrom = pn.childIndex;
            }
            else if(i+1 == numNodes)
            {
                if(pn.parent != null)
                    throw new Exception("This should be the root... and it's not.");

                if(Added)
                {
                    //Console.WriteLine("AddING (" + result[0] + "," + result[1] + ") to child " + comingFrom + " from " + pn.parent);
                    if(comingFrom != -1)
                    {
                        sol.m_through = comingFrom;
                        pn.valueRoute[comingFrom].Add(sol);
                    }
                }

            }

        }
    }
Пример #5
0
    public void mctsSearch(long a_timeDue) { //TODO: prune bad boards: 1. we will die next turn, 2. we will die this turn

        long remaining = a_timeDue - DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

        NEXT_TICKS=0;
        int numIters = 500;
        double invIters = 0.0;

        //if(treePolicy is ParetoEGreedyTreePolicy)
        //{
        //    ((ParetoEGreedyTreePolicy) treePolicy).epsilon = 0.1;
        //    invIters = 0.1/numIters;
        //}

        for (int i = 0; i < numIters; i++) {
        //while(remaining > 10)   {
        //while(remaining > 0)   {
            m_runList.Clear();
            m_runList.Add(this); //root always in.

            //m_pi.reset(this.state);
            if (this.isExhausted)
            {
                //Helpfunctions.Instance.logg("exit at num: " + i);
                break; //if all exhausted, then return
            }
            ParetoTreeNode selected = treePolicy();
            AddPlayoutInfoTree();
            //double[] delta = selected.rollOut();
            Playfield endTurnState = selected.rollOut();
            //double[] delta = m_player.getHeuristic().value(endTurnState);
            double[] delta = null;
            switch (m_player.heuristicType)
            { 
                case HeuristicType.Boardvalue:
                    delta = new double[] { endTurnState.getBoardValue(), -endTurnState.getEnemyBoardValue(), endTurnState.getHandMinionValue() };
                    break;

                case HeuristicType.LethalCheck:
                    delta = new double[] { endTurnState.getLethalScore()};
                    break;
            
            }
            //double[] delta = new double[] {endTurnState.getBoardValue(), -endTurnState.getEnemyBoardValue(), endTurnState.getHandMinionValue()};
            //endTurnState.printBoard();         
            Solution deltaSol = new Solution(delta, endTurnState);
            selected.backUp(delta, deltaSol, true, selected.childIndex);

            m_numIters++;
            remaining = a_timeDue - DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

            //if(treePolicy is ParetoEGreedyTreePolicy)
            //{
            //    ((ParetoEGreedyTreePolicy) treePolicy).epsilon -= invIters;
            //}
            if (m_player.heuristicType == HeuristicType.LethalCheck && (deltaSol.m_data[0] == 1.0 || deltaSol.m_data[0] == 0)) //we got lethal
            {
                int debug = 1;
                return;
            }
        }
        //Helpfunctions.Instance.logg("normal exit: 500");
    }