14   template<Player P,Ptype Type>
 
   24   direct->push_back(std::make_pair(p.
ptypeO(), p.
square()));
 
   28 template <osl::Player P>
 
   31                       PtypeOSquareVector& my_pieces, 
 
   32                       PtypeOSquareVector& op_pieces)
 
   35   store_t op_pieces_store(&op_pieces, effect_to);
 
   37   if (op_pieces.empty())
 
   40   if ((
int)op_pieces.size() <= state.countEffect(P, effect_to))
 
   42     store_t my_pieces_store(&my_pieces, effect_to);
 
   43     state.forEachEffect<P,store_t>(effect_to, my_pieces_store); 
 
   47   PtypeOSquareVector my_pieces_more;
 
   48   FindEffectMore action = { &my_pieces, &my_pieces_more, effect_to, &state };
 
   52   my_pieces.push_back(my_pieces_more.begin(), my_pieces_more.end());
 
   54   if (op_pieces.size() <= my_pieces.size())
 
   56   my_pieces_more.clear();
 
   58   for (
size_t i=0; i<op_pieces.size(); ++i) {
 
   59     findAdditionalPieces(state, P, effect_to, op_pieces[i].second, my_pieces_more);
 
   61   my_pieces.push_back(my_pieces_more.begin(), my_pieces_more.end());
 
   64 template <osl::Player P>
 
   67                                PtypeOSquareVector& my_pieces, 
 
   68                                PtypeOSquareVector& op_pieces)
 
   74   store_t op_pieces_store(&op_pieces, to);
 
   76   if (op_pieces.empty())
 
   80   const Piece moved = state.pieceOnBoard(from);
 
   82   ignore.set(moved.
number());
 
   83   if ((
int)op_pieces.size() < state.countEffect(P, to))
 
   85     store_t my_pieces_store(&my_pieces, to);
 
   86     state.forEachEffect<P,store_t>(to, my_pieces_store, ignore);
 
   91   PtypeOSquareVector my_pieces_more;
 
   92   findAdditionalPieces(state, move.
player(), to, moved.
square(), my_pieces_more);
 
   94   FindEffectMore action = { &my_pieces, &my_pieces_more, to, &state };
 
   98   my_pieces.push_back(my_pieces_more.begin(), my_pieces_more.end());
 
  100   if (op_pieces.size() < my_pieces.size())
 
  102   my_pieces_more.clear();
 
  104   for (
size_t i=0; i<op_pieces.size(); ++i) {
 
  105     findAdditionalPieces(state, P, to, op_pieces[i].second, my_pieces_more);
 
  107   my_pieces.push_back(my_pieces_more.begin(), my_pieces_more.end());
 
  110 template <osl::Player P>
 
  113                   PtypeOSquareVector& my_pieces, 
 
  114                   PtypeOSquareVector& op_pieces,
 
  115                   const PieceMask& my_pin, 
const PieceMask& op_pin,
 
  122   CArray<int,Piece::SIZE> vals;
 
  126   bool op_deleted=
false, my_deleted=
false;
 
  127   for (i=0;i<op_pieces.size();i++,c++)
 
  131         Square from=op_pieces[i].second;
 
  132         Piece p=state.pieceAt(from);
 
  135         assert(p.
owner()==Opponent);
 
  136         if(op_pin.test(num) && !state.pinnedCanMoveTo<Opponent>(p,
target) &&
 
  138           Piece attacker=state.pinAttacker<Opponent>(p);
 
  139           assert(attacker.
owner()==P);
 
  141           if(attacker_sq != move_from){
 
  143             for(;j<my_pieces.size();j++) 
if(my_pieces[j].second==attacker_sq) 
break;
 
  145               if(j==my_pieces.size() || op_pieces.size()<=j+1 ){
 
  146                 for(
size_t k=i;k<op_pieces.size()-1;k++)
 
  147                   op_pieces[k]=op_pieces[k+1];
 
  148                 op_pieces.pop_back();
 
  152                 std::pair<PtypeO,Square> v=op_pieces[i];
 
  153                 for(
size_t k=i;k<=j;k++)
 
  154                   op_pieces[k]=op_pieces[k+1];
 
  168       ptypeO = op_pieces[i].first;
 
  171             || op_pieces[i].second.canPromote<Opponent>());
 
  181     if (i>=my_pieces.size()){
 
  185         Square from=my_pieces[i].second;
 
  186         Piece p=state.pieceAt(from);
 
  188         assert(p.
owner()==P);
 
  190         if(my_pin.test(num) && !state.pinnedCanMoveTo<P>(p,
target) &&
 
  192           Piece attacker=state.pinAttacker<P>(p);
 
  193           assert(attacker.
owner()==Opponent);
 
  196           for(;j<op_pieces.size();j++) 
if(op_pieces[j].second==attacker_sq) 
break;
 
  198             if(j==op_pieces.size() || my_pieces.size()<=j ){
 
  199               for(
size_t k=i;k<my_pieces.size()-1;k++)
 
  200                 my_pieces[k]=my_pieces[k+1];
 
  201               my_pieces.pop_back();
 
  205               std::pair<PtypeO,Square> v=my_pieces[i];
 
  206               for(
size_t k=i;k<j;k++)
 
  207                 my_pieces[k]=my_pieces[k+1];
 
  217       ptypeO=my_pieces[i].first;
 
  220             || my_pieces[i].second.canPromote<P>());
 
  228   for (
int j=i-1;j>=0;j--)
 
  236 template <osl::Player P>
 
  238                                 const PieceMask& my_pin, 
const PieceMask& op_pin,
 
  241   assert(state.isAlmostValidMove(move));
 
  245   PtypeOSquareVector my_pieces, op_pieces;
 
  247   if (from.isPieceStand())
 
  249     findEffectPieces<P>(state, to, my_pieces, op_pieces);
 
  254     findEffectPiecesAfterMove<P>(state, move, my_pieces, op_pieces);
 
  256   if (op_pieces.empty())
 
  258   return val + computeValue<P>(state, move, my_pieces, op_pieces, my_pin, op_pin, table);
 
  262                         const PieceMask& my_pin, 
const PieceMask& op_pin,
 
  268     return seeInternal<BLACK>(state, move, my_pin, op_pin, *table);
 
  270     return -seeInternal<WHITE>(state, move, my_pin, op_pin, *table);
 
  277                           PtypeOSquareVector& 
out)
 
  284   Piece candidate=state.nextPiece(from, step);
 
  289        candidate=state.nextPiece(candidate.
square(), step))
 
  291     if (candidate.
owner() != attack)
 
  297     out.push_back(std::make_pair(candidate.
ptypeO(), candidate.
square()));