14 template <osl::Player P>
 
   26     if (it->isDominatedByProofPieces<P>(
this, pass_left))
 
   28       if (!it->getValue<P>(pass_left).isFinal())
 
   32         it->setResult<P>(pass_left, getValue<P>(pass_left),
 
   33                          getBestMove<P>(pass_left),
 
   39         if (!it->getValue<P>(pass_left).isCheckmateSuccess())
 
   42           std::cerr << <
"for " < P << 
"\tat pass_left:" << pass_left << 
"\tcontradiction occured\n" << *it << *
this;
 
   53 template <osl::Player P>
 
   58   for (RecordList::iterator it = same_board_list->begin();
 
   59        it != same_board_list->end(); it++)
 
   65     if (it->isDominatedByDisproofPieces<P>(
this, pass_left))
 
   67       if (!it->getValue<P>(pass_left).isFinal())
 
   71         it->setResult<P>(pass_left, getValue<P>(pass_left),
 
   72                          getBestMove<P>(pass_left),
 
   78         if (!it->getValue<P>(pass_left).isCheckmateFail())
 
   81           std::cerr << <
"for " < P << 
"\tat pass_left:" << pass_left << 
"\tcontradiction occured\n" << *it << *
this;
 
   95     template <
class NumEffectState>
 
   98       if (state.hasPieceOnStand(turn, 
PAWN))
 
  100       if (state.hasPieceOnStand(turn, 
LANCE))
 
  102       if (state.hasPieceOnStand(turn, 
KNIGHT))
 
  104       if (state.hasPieceOnStand(turn, 
SILVER))
 
  106       if (state.hasPieceOnStand(turn, 
GOLD))
 
  108       if (state.hasPieceOnStand(turn, 
BISHOP))
 
  110       if (state.hasPieceOnStand(turn, 
ROOK))
 
  114     template <
class NumEffectState>
 
  118       if (cheapest == 
PAWN)
 
  120         if (state.hasPieceOnStand(turn, 
LANCE))
 
  122         if (state.hasPieceOnStand(turn, 
KNIGHT))
 
  124         if (state.hasPieceOnStand(turn, 
SILVER))
 
  126         if (state.hasPieceOnStand(turn, 
GOLD))
 
  128         if (state.hasPieceOnStand(turn, 
BISHOP))
 
  130         if (state.hasPieceOnStand(turn, 
ROOK))
 
  141 template <osl::Player T>
 
  150   const bool under_attack = state->inCheck(T);
 
  158   already_set_up = 
true;
 
  162   rzone<BLACK>()[1] = rzone<BLACK>()[0];
 
  165   rzone<WHITE>()[1] = rzone<WHITE>()[0];
 
  169     setUpAttackNode<T>();
 
  173     setUpDefenseNode<T>();
 
  178 template <osl::Player T>
 
  189   best_move<O>()[0] = pass;
 
  191   if (!values<T>()[0].isFinal() &&
 
  192       state->template kingSquare<O>().isOnBoard())
 
  210       setResult<T>(0, result_fixed,
 
  211                    best_move, 
false, &proof_pieces);
 
  217       PieceStand disproof_pieces = getPieceStand<O>();
 
  219       setResult<T>(0, result_fixed,
 
  226       setResult<T>(0, result_fixed,
 
  228       if (!values<T>()[1].isFinal())
 
  238 template <osl::Player T>
 
  247   for (
size_t i = 0; i < SIZE; ++i)
 
  253   if (!values<O>()[0].isFinal() &&
 
  254       state->template kingSquare<T>().isOnBoard())
 
  268       setResult<O>(0, result_fixed,
 
  274       PieceStand disproof_pieces = getPieceStand<T>();
 
  279       setResult<O>(0, result_fixed,
 
  280                    best_move, 
false, &disproof_pieces);
 
  286       setResult<O>(0, result_fixed,
 
  288       if (!values<O>()[1].isFinal())
 
  300 template <osl::Player P>
 
  311     mg->generateSlow(P, *state, move_list);
 
  315     mg->generateWithRzoneSlow(P, *state, 
this, pass_left, move_list);
 
  320   for (NtesukiMoveList::iterator move_it = move_list.begin();
 
  321        move_it != move_list.end(); move_it++)
 
  323     const Move move = move_it->getMove();
 
  325     if (move_it->isPass())
 
  327       unsigned int p_a = 1, d_a = 1, p_d = 1, d_d = 1;
 
  328       move_it->setHEstimates(p_a, d_a, p_d, d_d);
 
  332     unsigned int p_a = 1, d_a = 1, p_d = 1, d_d = 1;
 
  334     if (state->template kingSquare<O>().isOnBoard())
 
  339     if (state->template kingSquare<P>().isOnBoard())
 
  346     move_it->setHEstimates(p_a, d_a, p_d, d_d);
 
  353     if (state->hasEffectAt(O, to))
 
  357         if ((ptype != cheapest)  && (ptype != secondCheapest))
 
  359           move_it->setInterpose();
 
  361         else if((! state->hasEffectAt(P, to))   
 
  362                 && (! state->hasMultipleEffectAt(O, to)))
 
  364           move_it->setInterpose();
 
  367       else if ((ptype != 
KING) &&
 
  369                (! state->hasMultipleEffectAt(P, to)))
 
  371         move_it->setInterpose();
 
  376     if (delay_lame_long &&
 
  379         (! state->hasMultipleEffectAt(P, to)))
 
  381       const Square opKingSquare = state->template kingSquare<O>();
 
  382       const Square myKingSquare = state->template kingSquare<P>();
 
  383       bool close_to_king = 
false;
 
  386         int distance = (opKingSquare.
x() - to.
x()) * (opKingSquare.
x() - to.
x()) +
 
  387           (opKingSquare.
y() - to.
y()) * (opKingSquare.
y() - to.
y());
 
  390           close_to_king = 
true;
 
  393       if (myKingSquare.isOnBoard())
 
  395         int distance = (myKingSquare.x() - to.
x()) * (myKingSquare.x() - to.
x()) +
 
  396           (myKingSquare.y() - to.
y()) * (myKingSquare.y() - to.
y());
 
  399           close_to_king = 
true;
 
  405         move_it->setLameLong();
 
  412         PawnCheckmateMoves::effectiveOnlyIfPawnCheckmate<P>(ptype, from, to))
 
  414       move_it->setNoPromote();
 
  433 template <osl::Player P>
 
  442   const NtesukiRecord* record_child = table->findWithMove(
this, move);
 
  444   proof_pieces = record_child->
getPDPieces<P>(pass_left);
 
  457 template <osl::Player P>
 
  469   mg->generate<O>(*state, 
moves);
 
  471   for (NtesukiMoveList::iterator move_it = moves.begin();
 
  472        move_it != moves.end(); move_it++)
 
  475     const NtesukiRecord* record_child = table->findWithMove(
this, move);
 
  486         return piece_stand<P>();
 
  495     proof_pieces = proof_pieces.
max(proof_pieces_child);
 
  506       if (!state->hasPieceOnStand(O, ptype))
 
  508         const int diff = state->countPiecesOnStand(P, ptype) - proof_pieces.
get(ptype);
 
  510         if (diff) proof_pieces.
add(ptype, diff);
 
  517 template <osl::Player A>
 
  534   else if (best_move.
isPass())
 
  536     const NtesukiRecord* record_pass = table->findWithMove(
this, best_move);
 
  538     proof_pieces = record_pass->
getPDPieces<A>(pass_left - 1);
 
  542     proof_pieces = calcProofPiecesOr<A>(pass_left, best_move);
 
  548     proof_pieces = calcProofPiecesAnd<A>(pass_left);
 
  551   ntesuki_assert(piece_stand<A>().
template hasMoreThan<BLACK>(proof_pieces));
 
  552   for (
unsigned int j = pass_left; j < SIZE; j++)
 
  554     setPDPieces<A>(j, proof_pieces);
 
  555     setPDPieces<D>(j, proof_pieces);
 
  559 template <osl::Player P>
 
  574     disproof_pieces = *ps;
 
  578     const NtesukiRecord* record_pass = table->findWithMove(
this, m);
 
  581     disproof_pieces = record_pass->
getPDPieces<P>(pass_left - 1);
 
  589     const NtesukiRecord* record_child = table->findWithMove(
this, m);
 
  591     disproof_pieces = record_child->
getPDPieces<P>(pass_left);
 
  609     generateMoves<P>(
moves, 0, 
true);
 
  611     for (NtesukiMoveList::iterator move_it = moves.begin();
 
  612          move_it != moves.end(); move_it++)
 
  614       const NtesukiRecord* record_child = table->findWithMove(
this, *move_it);
 
  617         if (move_it->isPass() ||
 
  619              (!move_it->isCheck() || move_it->isNoPromote())))
 
  625           setPDPieces<P>(pass_left, piece_stand<O>());
 
  633       disproof_pieces = disproof_pieces.
max(disproof_pieces_child);
 
  646         if (!state->hasPieceOnStand(P, ptype))
 
  648           const int diff = state->countPiecesOnStand(O, ptype) - disproof_pieces.
get(ptype);
 
  650           if (diff) disproof_pieces.
add(ptype, diff);
 
  657   ntesuki_assert(piece_stand<O>().isSuperiorOrEqualTo(disproof_pieces))
 
  659   setPDPieces<P>(pass_left, disproof_pieces);
 
  662 template <osl::Player P>
 
  679     setProofPieces<P>(pass_left, r, m, ps);
 
  682     for (
unsigned int j = pass_left; j < SIZE; j++)
 
  685       best_move<P>()[j] = m;
 
  687       if (!values<O>()[j].isCheckmateFail())
 
  692         best_move<O>()[j] = m;
 
  698       propagate_proof<P>(pass_left);
 
  701 #ifdef COLLECT_GARBAGE 
  706       moves.remove_if(different_move);
 
  713     setDisproofPieces<P>(pass_left, r, m, ps);
 
  715     values<P>()[pass_left] = r;
 
  716     best_move<P>()[pass_left] = m;
 
  718     if (pass_left != 0 &&
 
  719         !values<P>()[pass_left - 1].isCheckmateFail()
 
  722       setFinal<P>(pass_left - 1, r, m, ps);
 
  727       propagate_disproof<P>(pass_left);
 
  730 #ifdef COLLECT_GARBAGE 
  734       for (NtesukiMoveList::iterator move_it = 
moves.begin();
 
  735            move_it != 
moves.end(); move_it++)
 
  737         bool not_best_move = 
true;
 
  738         for (
size_t i = 0; i < SIZE; i++)
 
  740           if (&(*move_it) != best_move<O>()[pass_left]) not_best_move = 
false;
 
  745           move_it->clearRecord();
 
  757 template <osl::Player P>
 
  778     value_before_final = values<P>()[i];
 
  779     setFinal<P>(i, r, m, ps);
 
  786     for (; order < i; order++)
 
  795     for (; order < (int)SIZE; order++)
 
  798       if (values<P>()[
order].isCheckmateFail()) 
continue;
 
  816   if (key.turn() == P &&
 
  817       values<P>()[i].isCheckmateSuccess())
 
  821   else if (key.turn() != P &&
 
  822            values<P>()[i].isCheckmateFail())
 
  831 template <osl::Player P>
 
  839   const PieceStand& my_stand = piece_stand<P>();
 
  847 template <osl::Player P>
 
  856   const PieceStand& my_stand = piece_stand<O>();
 
  864 template <osl::Player P>
 
  869   const PieceStand& mystand = key.getPieceStand();
 
  872   if (mystand == opstand) 
return false;
 
  879 template <osl::Player A>
 
  883   return use_old<A>()[pass_left];
 
  886 template <osl::Player A>
 
  891   use_old<A>()[pass_left] = value;
 
  895 template <osl::Player P>
 
  901   const list_t& list = loop_path_list<P>()[pass_left];
 
  902   for (list_t::const_iterator it = list.begin(); it != list.end(); it++)
 
  912 template <osl::Player P>
 
  918   list_t& list = loop_path_list<P>()[pass_left];
 
  919   list.push_front(path);
 
  922 template <osl::Player P>
 
  928   return  values<P>()[i];
 
  931 template <osl::Player P>
 
  938   if (values<P>()[i].isFinal()) 
return values<P>()[i];
 
  939   if (isLoopWithPath<P>(i, path))
 
  943   return values<P>()[i];
 
  947 template <osl::Player P>
 
  955   if (values<P>()[max_pass_left].isFinal()) 
return values<P>()[max_pass_left];
 
  956   if (isLoopWithPath<P>(max_pass_left, path))
 
  963   if (iwscheme == pn_iw)
 
  965     unsigned int min_proof = ret.
proof();
 
  966     for (
int pass_left = 0; pass_left < max_pass_left; ++pass_left)
 
  968       if (isLoopWithPath<P>(pass_left, path)) 
continue;
 
  975   else if (iwscheme == strict_iw)
 
  977     for (
int pass_left = 0; pass_left < max_pass_left; ++pass_left)
 
  979       if (isLoopWithPath<P>(pass_left, path)) 
continue;
 
  991 template <osl::Player P>
 
 1000   if (values<P>()[max_pass_left].isFinal()) 
return values<P>()[max_pass_left];
 
 1001   if (isLoopWithPath<P>(max_pass_left, path))
 
 1007   if (psscheme && max_pass_left != 0)
 
 1013     const NtesukiResult result_opponent = getValueOr<O>(max_pass_left - 1,
 
 1016     if (!result_opponent.
isFinal() &&
 
 1020                           result_opponent.
proof() + inversion_cost);
 
 1026 template <osl::Player P>
 
 1031   return best_move<P>()[i];
 
 1034 template <osl::Player P>
 
 1039   return is_ntesuki<P>()[pass_left];
 
 1042 template <osl::Player P>
 
 1048   is_ntesuki<P>()[pass_left] = 
true;
 
 1051 template <osl::Player P>
 
 1056   return propagated_oracle<P>()[pass_left];
 
 1059 template <osl::Player P>
 
 1064   assert(
false == propagated_oracle<P>()[pass_left]);
 
 1065   propagated_oracle<P>()[pass_left] = 
true;
 
 1068 template <osl::Player P>
 
 1073   return by_fixed<P>();
 
 1076 template <osl::Player P>
 
 1081   return pdpieces<P>()[pass_left];
 
 1084 template <osl::Player P>
 
 1089   pdpieces<P>()[pass_left] = p;