示例#1
0
 public MoveList(Position pos, GenType T)
 {
     cur              = 0;
     mlist            = new ExtMove[Types.MAX_MOVES];
     last             = MoveList.generate(pos, mlist, 0, T);
     mlist[last].move = MoveS.MOVE_NONE;
 }
        /// generate_next_stage() generates, scores and sorts the next bunch of moves,
        /// when there are no more moves to try for the current stage.
        public void generate_next_stage()
        {
            cur = 0;

            switch (++stage)
            {
            case StagesS.CAPTURES_S1:
            case StagesS.CAPTURES_S3:
            case StagesS.CAPTURES_S4:
            case StagesS.CAPTURES_S5:
            case StagesS.CAPTURES_S6:
                end = MoveList.generate(pos, moves, 0, GenTypeS.CAPTURES);
                score_captures();
                return;

            case StagesS.KILLERS_S1:
                cur = Types.MAX_MOVES;
                end = cur + 2;

                moves[Types.MAX_MOVES].move     = ss.killers0;
                moves[Types.MAX_MOVES + 1].move = ss.killers1;
                moves[Types.MAX_MOVES + 2].move = moves[Types.MAX_MOVES + 3].move = MoveS.MOVE_NONE;
                moves[Types.MAX_MOVES + 4].move = moves[Types.MAX_MOVES + 5].move = MoveS.MOVE_NONE;

                // Please note that following code is racy and could yield to rare (less
                // than 1 out of a million) duplicated entries in SMP case. This is harmless.

                // Be sure countermoves are different from killers
                for (int i = 0; i < 2; ++i)
                {
                    if (countermoves[i] != moves[cur].move &&
                        countermoves[i] != moves[cur + 1].move)
                    {
                        moves[end++].move = countermoves[i];
                    }
                }

                // Be sure followupmoves are different from killers and countermoves
                for (int i = 0; i < 2; ++i)
                {
                    if (followupmoves[i] != moves[cur].move &&
                        followupmoves[i] != moves[cur + 1].move &&
                        followupmoves[i] != moves[cur + 2].move &&
                        followupmoves[i] != moves[cur + 3].move)
                    {
                        moves[end++].move = followupmoves[i];
                    }
                }

                return;

            case StagesS.QUIETS_1_S1:
                endQuiets = end = MoveList.generate(pos, moves, 0, GenTypeS.QUIETS);
                score_quiets();
                end = partition(moves, cur, end);
                insertion_sort(moves, cur, end);
                return;

            case StagesS.QUIETS_2_S1:
                cur = end;
                end = endQuiets;
                if (depth >= 3 * DepthS.ONE_PLY)
                {
                    insertion_sort(moves, cur, end);
                }
                return;

            case StagesS.BAD_CAPTURES_S1:
                // Just pick them in reverse order to get MVV/LVA ordering
                cur = Types.MAX_MOVES - 1;
                end = endBadCaptures;
                return;

            case StagesS.EVASIONS_S2:
                end = MoveList.generate(pos, moves, 0, GenTypeS.EVASIONS);
                if (end > 1)
                {
                    score_evasions();
                }
                return;

            case StagesS.QUIET_CHECKS_S3:
                end = MoveList.generate(pos, moves, 0, GenTypeS.QUIET_CHECKS);
                return;

            case StagesS.EVASION:
            case StagesS.QSEARCH_0:
            case StagesS.QSEARCH_1:
            case StagesS.PROBCUT:
            case StagesS.RECAPTURE:
                stage = StagesS.STOP;
                end   = cur + 1;
                break;

            case StagesS.STOP:
                end = cur + 1;     // Avoid another next_phase() call
                return;

            default:
                Debug.Assert(false);
                break;
            }
        }