10 #include "osl/move_classifier/check.h" 
   11 #include "osl/move_generator/escape.h" 
   13 #include "osl/move_generator/addEffect.h" 
   14 #include "osl/move_generator/addEffect.tcc" 
   20 #include "osl/move_generator/capture.h" 
   21 #include "osl/move_generator/capture.tcc" 
   22 #include "osl/move_generator/captureEffectToAroundKing8.h" 
   24 #include "osl/move_action/safeFilter.h" 
   45 #if OSL_WORDSIZE == 64 
   46       const PieceMask bigPieceMask (container::PieceMaskBase(
 
   52       const PieceMask pieceMask = (state.piecesOnBoard (player)
 
   53                                    & state.effectAt (pos)
 
   55       return pieceMask.any();
 
   56 #elif OSL_WORDSIZE == 32 
   59       PieceMask bigPieceMask;
 
   64       const PieceMask pieceMask = (state.piecesOnBoard (player)
 
   65                                    & state.effectAt (pos)
 
   67       return pieceMask.any();
 
   76       using namespace move_classifier;
 
   82       move_action::SafeFilter<P, state::NumEffectState, move_action::Store> store_safe(state, store);
 
   91         : state(state), action(action)
 
  100       const NumEffectState& 
state;
 
  104     template <Player P, Ptype T>
 
  119     GetAllAttackMoves::GetAllAttackMoves(
bool verbose)
 
  120       : NtesukiAttackMoveGenerator(verbose) {}
 
  121     GetAllAttackMoves::~GetAllAttackMoves() {}
 
  124     generate(
const NumEffectState& state,
 
  125              NtesukiMoveList& 
moves)
 
  127       MoveVector move_candidates;
 
  129       moves = NtesukiMoveList(state, move_candidates);
 
  131     template void GetAllAttackMoves::generate<BLACK>(
const NumEffectState& state,
 
  132                                                      NtesukiMoveList& 
moves);
 
  133     template void GetAllAttackMoves::generate<WHITE>(
const NumEffectState& state,
 
  134                                                      NtesukiMoveList& 
moves);
 
  138     GetAttackMoves::GetAttackMoves(
bool verbose)
 
  139       : NtesukiAttackMoveGenerator(verbose) {}
 
  140     GetAttackMoves::~GetAttackMoves() {}
 
  143     generate(
const NumEffectState& state,
 
  144              NtesukiMoveList& 
moves)
 
  147       const Square pos = state.template kingSquare<P>();
 
  148       const bool check = state.hasEffectAt(PlayerTraits<P>::opponent, pos);
 
  152         MoveVector move_candidates;
 
  154         moves = NtesukiMoveList(state, move_candidates);
 
  158       MoveVector check_candidates;
 
  159       getCheckMoves<P>(state, check_candidates);
 
  161       MoveVector move_candidates;
 
  162       move_action::Store 
store(move_candidates);
 
  165       capture<P, ROOK>(state, 
store);
 
  166       capture<P, BISHOP>(state, 
store);
 
  167       capture<P, GOLD>(state, 
store);
 
  168       capture<P, SILVER>(state, 
store);
 
  169       capture<P, KNIGHT>(state, 
store);
 
  170       capture<P, LANCE>(state, 
store);
 
  174       for (
size_t i = 0; i < move_candidates.size(); ++i)
 
  176         const Move m = move_candidates[i];
 
  177         if (check_candidates.isMember(move_candidates[i])
 
  189       for (
size_t i = 0; i < move_candidates.size(); ++i)
 
  195                          PlayerMoveAdaptor<move_classifier::Check>::
 
  196                          isMember(state, move_candidates[i])
 
  197                          || (std::cerr << std::endl
 
  199                              << check_candidates << std::endl
 
  200                              << move_candidates << std::endl,
 
  204         moves.push_front(NtesukiMove(move_candidates[i], NtesukiMove::NONE));
 
  206       for (
size_t i = 0; i < check_candidates.size(); ++i)
 
  208         moves.push_front(NtesukiMove(check_candidates[i], NtesukiMove::CHECK_FLAG));
 
  212       MoveVector all_moves;
 
  213       MoveVector move_candidates;
 
  216       const Square opKingSquare =
 
  217         state.kingSquare (
alt(state.turn ()));
 
  219       for (
unsigned int i=0; i<all_moves.size(); ++i)
 
  221         const Move m = all_moves[i];
 
  229         const Square from = m.from();
 
  234           move_candidates.push_back(m);
 
  238           move_candidates.push_back(m);
 
  242           const Square to = m.to();
 
  243           const Piece atTo = state.pieceOnBoard (to);
 
  246               && (atTo.owner() == 
alt (state.turn ())))
 
  248             move_candidates.push_back(m);
 
  252       moves = NtesukiMoveList(state, move_candidates);
 
  255     template void GetAttackMoves::generate<BLACK>(
const NumEffectState& state,
 
  256                                                   NtesukiMoveList& 
moves);
 
  257     template void GetAttackMoves::generate<WHITE>(
const NumEffectState& state,
 
  258                                                   NtesukiMoveList& 
moves);
 
  262     GetMultipleAttackMoves::GetMultipleAttackMoves(
bool verbose)
 
  263       : NtesukiAttackMoveGenerator(verbose) {}
 
  264     GetMultipleAttackMoves::~GetMultipleAttackMoves() {}
 
  267     generate(
const NumEffectState& state,
 
  268              NtesukiMoveList& moves)
 
  270       assert (state.turn() == P);
 
  271       MoveVector all_moves;
 
  272       MoveVector move_candidates;
 
  275       const Square opKingSquare =
 
  276         state.kingSquare (
alt(state.turn ()));
 
  278       for (
unsigned int i=0; i<all_moves.size(); ++i)
 
  280         const Move m = all_moves[i];
 
  281         const Square from = m.from();
 
  288           move_candidates.push_back(m);
 
  292           move_candidates.push_back(m);
 
  296           const Square to = m.to();
 
  297           const Piece atTo = state.pieceOnBoard (to);
 
  299               && (atTo.owner() == 
alt (state.turn ())))
 
  301             move_candidates.push_back(m);
 
  305       moves = NtesukiMoveList(state, move_candidates);
 
  307     template void GetMultipleAttackMoves::generate<BLACK>(
const NumEffectState& state,
 
  308                                                           NtesukiMoveList& 
moves);
 
  309     template void GetMultipleAttackMoves::generate<WHITE>(
const NumEffectState& state,
 
  310                                                           NtesukiMoveList& 
moves);