00001 #ifndef _GENERATE_ESCAPE_MOVES_TCC
00002 #define _GENERATE_ESCAPE_MOVES_TCC
00003
00004 #include "osl/move_generator/escape_.h"
00005 #include "osl/move_action/concept.h"
00006 #include "osl/move_action/store.h"
00007 #include "osl/container/moveVector.h"
00008 namespace osl
00009 {
00010 namespace move_generator
00011 {
00012 template<Player P,class State,class Action>
00013 void Escape<P,State,Action>::
00014 generateDropAll(const State& state,Position to,Action& action)
00015 {
00016 generateDrop<PAWN>(state,to,action);
00017 generateDrop<LANCE>(state,to,action);
00018 generateDrop<KNIGHT>(state,to,action);
00019 generateDrop<SILVER>(state,to,action);
00020 generateDrop<GOLD>(state,to,action);
00021 generateDrop<BISHOP>(state,to,action);
00022 generateDrop<ROOK>(state,to,action);
00023 }
00024
00025 template<Player P,class State,class Action>
00026 void Escape<P,State,Action>::
00027 generateBlockingKing(const State& state,Piece p,Position from,Action &action,move_action::NotKingOpenFilter<P,State,Action>& safe_action)
00028 {
00029 Position to=p.position();
00030 Offset offset=Board_Table.getShortOffset(Offset32(from,to));
00031 assert(!offset.zero());
00032 for(Position pos=to+offset;pos!=from;pos+=offset){
00033 assert(state.getPieceAt(pos).isEmpty());
00034
00035 typedef effect_action::SimpleMove<move_action::NotKingOpenFilter<P,State,Action> > simple_action_t;
00036 simple_action_t simpleAction(safe_action);
00037 state.template forEachEffectNotBy<P ,simple_action_t>(pos,p,simpleAction);
00038
00039 generateDropAll(state,pos,action);
00040 }
00041 }
00042
00043 template<Player P,class State,class Action>
00044 void Escape<P,State,Action>::
00045 generateBlocking(const State& state,Piece p,Position from,Action &action)
00046 {
00047 Position to=p.position();
00048 assert(from.isOnBoard());
00049 Offset offset=Board_Table.getShortOffset(Offset32(from,to));
00050 assert(!offset.zero());
00051 for(Position pos=to+offset;pos!=from;pos+=offset){
00052 assert(state.getPieceAt(pos).isEmpty());
00053
00054 typedef effect_action::SimpleMove<Action> simple_action_t;
00055 simple_action_t simpleAction(action);
00056 state.template forEachEffectNotBy<P ,simple_action_t>(pos,p,simpleAction);
00057
00058 generateDropAll(state,pos,action);
00059 }
00060 }
00061
00062 template<Player P,class State,class Action>
00063 template<Ptype Type>
00064 void Escape<P,State,Action>::
00065 generateMovesBy(const State& state,Piece p,Piece const attackerPiece,Action& action)
00066 {
00067 if(attackerPiece==Piece::EMPTY()){
00069 generateEscape<Type>(state,p,action);
00070 }
00071 else if(Type == KING){
00072 Position attackFrom=attackerPiece.position();
00073 move_action::NotKingOpenFilter<P,State,Action> safe_action(state,action);
00074
00075 generateCaptureKing( state, p, attackFrom, safe_action );
00077 generateEscape<Type>( state,p,action);
00079 generateBlockingKing(state,p,attackFrom,action,safe_action);
00080 }
00081 else{
00082 Position attackFrom=attackerPiece.position();
00083 generateCapture( state, p, attackFrom, action );
00085 generateEscape<Type>( state,p,action);
00087 generateBlocking(state,p,attackFrom,action);
00088 }
00089 }
00090
00091 template<Player P,class State,class Action>
00092 void Escape<P,State,Action>::
00093 generateKingEscape(const State& state,Move last_move,Action& action){
00094 Piece kingPiece=state.getPieceOf(KingTraits<P>::index);
00095 Piece attackerPiece;
00096 #ifndef NDEBUG
00097 const bool isAttacked=
00098 #endif
00099 state.template lastMoveIsCheck<P>(last_move,attackerPiece);
00100 assert(isAttacked);
00101 generateMovesBy<KING>(state,kingPiece,attackerPiece,action);
00102 }
00103 template<Player P,class State,class Action>
00104 template<Ptype Type>
00105 void Escape<P,State,Action>::
00106 generateMovesBy(const State& state,Piece p,Action& action)
00107 {
00108 Position target=p.position();
00109 Piece attackerPiece;
00110 bool isAttacked=
00111 state.template hasEffectBy<PlayerTraits<P>::opponent>(target,attackerPiece);
00112 assert(isAttacked);
00113 generateMovesBy<Type>(state,p,attackerPiece,action);
00114 }
00115
00116 template<Player P,class State,class Action>
00117 void Escape<P,State,Action>::
00118 generateMoves(const State& state,Piece piece,Piece attackerPiece,Action& action)
00119 {
00120 switch(piece.ptype()){
00121 case PAWN: generateMovesBy<PAWN>(state,piece,attackerPiece,action); break;
00122 case LANCE: generateMovesBy<LANCE>(state,piece,attackerPiece,action); break;
00123 case KNIGHT: generateMovesBy<KNIGHT>(state,piece,attackerPiece,action); break;
00124 case SILVER: generateMovesBy<SILVER>(state,piece,attackerPiece,action); break;
00125 case PPAWN: generateMovesBy<PPAWN>(state,piece,attackerPiece,action); break;
00126 case PLANCE: generateMovesBy<PLANCE>(state,piece,attackerPiece,action); break;
00127 case PKNIGHT: generateMovesBy<PKNIGHT>(state,piece,attackerPiece,action); break;
00128 case PSILVER: generateMovesBy<PSILVER>(state,piece,attackerPiece,action); break;
00129 case GOLD: generateMovesBy<GOLD>(state,piece,attackerPiece,action); break;
00130 case BISHOP: generateMovesBy<BISHOP>(state,piece,attackerPiece,action); break;
00131 case PBISHOP: generateMovesBy<PBISHOP>(state,piece,attackerPiece,action); break;
00132 case ROOK: generateMovesBy<ROOK>(state,piece,attackerPiece,action); break;
00133 case PROOK: generateMovesBy<PROOK>(state,piece,attackerPiece,action); break;
00134 case KING: generateMovesBy<KING>(state,piece,attackerPiece,action); break;
00135 default: assert(0);
00136
00137 }
00138 }
00139 template<Player P,class State,class Action>
00140 void Escape<P,State,Action>::
00141 generateMoves(const State& state,Piece piece,Action& action)
00142 {
00143 assert(piece.owner() == P);
00144 Position target=piece.position();
00145 Piece attackerPiece;
00146 state.template hasEffectBy<PlayerTraits<P>::opponent>(target,attackerPiece);
00147 generateMoves(state,piece,attackerPiece,action);
00148 }
00149 }
00150
00151 template <class State>
00152 void GenerateEscapeKing::generate(const State& state, MoveVector& out)
00153 {
00154 typedef move_action::Store store_t;
00155 store_t store(out);
00156 const Piece king =state.getKingPiece(state.getTurn());
00157 move_generator::GenerateEscapeOfTurn::generate(state, king, store);
00158 }
00159 }
00160
00161 #endif // _GENERATE_ESCAPE_MOVES_TCC
00162
00163
00164
00165
00166