3 #ifndef OSL_PIECEEVAL_TCC 
    4 #define OSL_PIECEEVAL_TCC 
   13     using container::PtypeOSquareVector;
 
   23                        const PtypeOSquareVector& src,
 
   24                        PtypeOSquareVector& 
out)
 
   26       for (
size_t i=0; i<src.size(); ++i)
 
   30         const Square from = src[i].second;
 
   33                 isMember(state,ptype,from,target)))
 
   35           out.push_back(src[i]);
 
   43                        const PtypeOSquareVector& src,
 
   44                        PtypeOSquareVector& 
out, 
Square except_for)
 
   46       for (
size_t i=0; i<src.size(); ++i)
 
   50         const Square from = src[i].second;
 
   53                 isMember(state,ptype,from,target,except_for)))
 
   55           out.push_back(src[i]);
 
   66                                  PtypeOSquareVector& my_pieces, 
 
   67                                  PtypeOSquareVector& op_pieces)
 
   70       store_t op_pieces_store(&op_pieces, effect_to);
 
   71       state.template forEachEffect<PlayerTraits<P>::opponent,store_t>
 
   72         (effect_to, op_pieces_store);
 
   73       if (! op_pieces.empty())
 
   75         store_t my_pieces_store(&my_pieces, effect_to);
 
   76         state.template forEachEffect<P,store_t>(effect_to, my_pieces_store);
 
   82                                           PtypeOSquareVector& my_pieces, 
 
   83                                           PtypeOSquareVector& op_pieces)
 
   85       using namespace effect_action;
 
   90       StorePtypeOSquare my_pieces_store(&my_pieces, to);
 
   91       StorePtypeOSquare op_pieces_store(&op_pieces, to);
 
   99         if (! shortOffset.
zero()){
 
  101           for (
Square pos=from-shortOffset; (p=state.pieceAt(pos)).isEmpty();
 
  109               my_pieces_store.store(p);
 
  117               op_pieces_store.store(p);
 
  122       state.template forEachEffect<PlayerTraits<P>::opponent,StorePtypeOSquare>
 
  123         (to, op_pieces_store);
 
  124       if (! op_pieces.empty())
 
  126         const Piece movePiece=state.pieceAt(from);
 
  127         state.template forEachEffectNotBy<P,StorePtypeOSquare>
 
  128           (to, movePiece,my_pieces_store);
 
  147                             const PtypeOSquareVector& my_pieces, 
 
  148                             const PtypeOSquareVector& op_pieces)
 
  151       CArray<int,Piece::SIZE> vals;
 
  154       for (i=0;i<op_pieces.size();i++)
 
  160           ptypeO = op_pieces[i].first;
 
  163                 || op_pieces[i].second.canPromote<Opponent>());
 
  172         if (i>=my_pieces.size()){
 
  177           ptypeO=my_pieces[i].first;
 
  180                 || my_pieces[i].second.canPromote<P>());
 
  188       for (
int j=i-1;j>=0;j--)
 
  206 template<osl::Player P>
 
  208 computeDiffAfterMove(
const NumEffectState& state, 
Move move)
 
  210   assert(P == state.turn());
 
  211   assert(state.isAlmostValidMove(move));
 
  214   PtypeOSquareVector my_pieces,op_pieces;
 
  226     TakeBackValue::findEffectPieces<P>(state, to, 
 
  227                                        my_pieces, op_pieces);
 
  231     val+=diffWithMove(state,move);
 
  233       findEffectPiecesAfterMove<P>(state, move, my_pieces, op_pieces);
 
  236   if (op_pieces.empty())
 
  239   PtypeOSquareVector my_safe_pieces, op_safe_pieces;
 
  243       select(state, to, my_pieces, my_safe_pieces);
 
  245       select(state, to, op_pieces, op_safe_pieces);
 
  250       select(state, to, my_pieces, my_safe_pieces, from);
 
  252       select(state, to, op_pieces, op_safe_pieces, from);
 
  255   my_safe_pieces.sort();
 
  256   op_safe_pieces.sort();
 
  258   return val + TakeBackValue::
 
  259     computeValue<P>(to, move.
ptypeO(), my_safe_pieces, op_safe_pieces);