15 #include "osl/move_action/safeFilter.h" 
   50 #if OSL_WORDSIZE == 64 
   51       const PieceMask bigPieceMask (container::PieceMaskBase(
 
   57       const PieceMask pieceMask = (state.piecesOnBoard (player)
 
   58                                    & state.effectAt (pos)
 
   60       return pieceMask.any();
 
   61 #elif OSL_WORDSIZE == 32 
   64       PieceMask bigPieceMask;
 
   69       const PieceMask pieceMask = (state.piecesOnBoard (player)
 
   70                                    & state.effectAt (pos)
 
   72       return pieceMask.any();
 
   81         : state(state), action(action)
 
   94     template <Player P, Ptype T>
 
  110     template <osl::Player T>
 
  115       if (state.inCheck(T))
 
  122         MoveVector all_moves;
 
  127         using namespace osl::move_classifier;
 
  128         for (
unsigned int i=0; i<all_moves.size(); ++i)
 
  130           const Move m = all_moves[i];
 
  152         = state.kingSquare<O>();
 
  153       if (state.inCheck(T))
 
  156         MoveVector move_candidates;
 
  160         setOrder<T>(state, 
moves);
 
  162       else if (pass_left == 0)
 
  165         MoveVector move_candidates;
 
  168           move_action::SafeFilter<T, move_action::Store>
 
  169             store_safe(state, store);
 
  176         for (NtesukiMoveList::iterator move_it = moves.begin();
 
  177              move_it != moves.end(); move_it++)
 
  180           const Move m = move_it->getMove();
 
  182           const Piece atTo = state.pieceOnBoard(to);
 
  185               state.countEffect2(O, to) == 1)
 
  187             move_it->setOrder(1);
 
  191             move_it->setOrder(0);
 
  196         moves.front().setOrder(0);
 
  200         return generate<T>(state, 
moves);
 
  204         int rzone_order = pass_left - 1;
 
  205         Rzone rzone_cur = record->
rzone<T>()[rzone_order];
 
  213           capture<T, ROOK>(state, 
store);
 
  214           capture<T, BISHOP>(state, 
store);
 
  215           capture<T, GOLD>(state, 
store);
 
  216           capture<T, SILVER>(state, 
store);
 
  217           capture<T, KNIGHT>(state, 
store);
 
  218           capture<T, LANCE>(state, 
store);
 
  220         for (
size_t i = 0; i < captures.size(); ++i)
 
  222           const Move m = captures[i];
 
  233         for (
int x = 1; x <=9; ++x)
 
  235           for (
int y = 1; y <=9; ++y)
 
  237             bool close_to_target = 
false;
 
  241               for (
int dx = -1; dx <=1; dx++)
 
  243                 for (
int dy = -1; dy <=1; dy++)
 
  247                   if (xx > 0 && xx < 10 && yy > 0 && yy < 10)
 
  252                     close_to_target |= rzone_cur.
test(pos2);
 
  259               close_to_target = rzone_cur.
test(pos);
 
  263               MoveVector king_blocks;
 
  266                 move_action::SafeFilter<T, move_action::Store>
 
  267                   store_safe(state, store2);
 
  270               for (
size_t i = 0; i < king_blocks.size(); ++i)
 
  272                 const Move m = king_blocks[i];
 
  279         setOrder<T>(state, 
moves);
 
  281         moves.front().setOrder(0);
 
  291       MoveVector all_moves;
 
  292       generate_all_moves<T>(state, all_moves);
 
  295       setOrder<T>(state, 
moves);
 
  297       if (!state.inCheck(T))
 
  300         moves.front().setOrder(0);
 
  309       const Square opKingSquare =
 
  310         state.kingSquare (
alt(state.turn ()));
 
  312       for (NtesukiMoveList::iterator move_it = moves.begin();
 
  313            move_it != moves.end(); move_it++)
 
  317           move_it->setOrder(3);
 
  320         const Move m = move_it->getMove();
 
  323         const Piece atTo = state.pieceOnBoard (to);
 
  326         if (move_it->isCheck())
 
  328           move_it->setOrder(0);
 
  334           move_it->setOrder(1);
 
  338           move_it->setOrder(1);
 
  341                  (atTo.
owner() == 
alt (state.turn ()))&&
 
  344           move_it->setOrder(1);
 
  350           move_it->setOrder(2);
 
  353                  (atTo.
owner() == 
alt (state.turn ())))
 
  355           move_it->setOrder(2);
 
  360           move_it->setOrder(3);
 
  365     template void NtesukiMoveGenerator::generate<BLACK>(
const NumEffectState& state,
 
  367     template void NtesukiMoveGenerator::generate<WHITE>(
const NumEffectState& state,
 
  370     template void NtesukiMoveGenerator::generateWithRzone<BLACK>(
const NumEffectState& state,
 
  374     template void NtesukiMoveGenerator::generateWithRzone<WHITE>(
const NumEffectState& state,