00001
00002
00003 #include "osl/state/pawnMaskState.h"
00004 #include "osl/state/pawnMaskState.tcc"
00005 #include "osl/apply_move/applyMove.h"
00006 #include "osl/apply_move/doUndoMoveLock.tcc"
00007 #include "osl/record/csaIOError.h"
00008 #include "osl/pieceTable.h"
00009 #include <iostream>
00010
00011 namespace osl
00012 {
00013
00014 template DoUndoMoveLock::DoUndoMoveLock(PawnMaskState&, Move);
00015
00016 }
00017
00018 osl::PawnMaskState::PawnMaskState(){
00019 init();
00020 }
00021
00022 void osl::PawnMaskState::initPawnMask(){
00023 pawnMask[0].clearAll();
00024 pawnMask[1].clearAll();
00025 for(int num=PtypeTraits<PAWN>::indexMin;
00026 num< PtypeTraits<PAWN>::indexLimit; num++){
00027 Piece p=getPieceOf(num);
00028 Player player=p.owner();
00029 Position pos=p.position();
00030 if(!pos.isPieceStand() && !p.isPromotedNotKingGold()){
00031 if (isPawnMaskSet(player,pos.x()))
00032 {
00033 std::cerr << std::endl << *this << p << std::endl;
00034 throw CsaIOError("2FU!");
00035 }
00036 pawnMask[playerToIndex(player)].set(pos);
00037 }
00038 }
00039 }
00040
00041 osl::PawnMaskState::PawnMaskState(osl::SimpleState const& st):SimpleState(st){
00042 initPawnMask();
00043 }
00044
00045 osl::PawnMaskState::PawnMaskState(Handicap h){
00046 init(h);
00047 }
00048
00049 void osl::PawnMaskState::init()
00050 {
00051 SimpleState::init();
00052 pawnMask[0].clearAll();
00053 pawnMask[1].clearAll();
00054 }
00055
00056
00057 void osl::PawnMaskState::init(Handicap h){
00058 SimpleState::init(h);
00059 initPawnMask();
00060 }
00061
00062
00063 osl::PawnMaskState::~PawnMaskState(){}
00064
00065 void osl::PawnMaskState::setPiece(Player player,Position pos,Ptype ptype){
00066 int num;
00067 for (num=0;num<40;num++){
00068 if (!used_mask.test(num) && Piece_Table.getPtypeOf(num)==unpromote(ptype)
00069 && (ptype!=KING ||
00070 num==PtypeTraits<KING>::indexMin+playerToIndex(player))){
00071 used_mask.set(num);
00072
00073 Piece p(player,ptype,num,pos);
00074 setPieceOf(num,p);
00075 setBoard(pos,p);
00076 if (pos==Position::STAND())
00077 standMask(player).set(num);
00078 else{
00079 if (ptype==PAWN)
00080 pawnMask[playerToIndex(player)].set(pos);
00081
00082 }
00083 return;
00084 }
00085 }
00086 std::cerr << "osl::PawnMaskState::setPiece! maybe too many pieces "
00087 << ptype << " " << pos << " " << player << "\n";
00088 abort();
00089 }
00090
00091 void osl::PawnMaskState::setPieceAll(Player player){
00092 for (int num=0;num<40;num++){
00093 if (!used_mask.test(num)){
00094 used_mask.set(num);
00095 standMask(player).set(num);
00096 Piece p(player,Piece_Table.getPtypeOf(num),num,Position::STAND());
00097 setPieceOf(num,p);
00098 }
00099 }
00100 }
00101
00102
00103 bool osl::PawnMaskState::isConsistent(bool showError) const
00104 {
00105 if(!SimpleState::isConsistent(showError))
00106 return false;
00107
00108 {
00109 CArray<BitXmask,2> pawnMask1;
00110 pawnMask1[0].clearAll();
00111 pawnMask1[1].clearAll();
00112 for (int num=PtypeTraits<PAWN>::indexMin;
00113 num<PtypeTraits<PAWN>::indexLimit;num++){
00114 if (isOnBoard(num)){
00115 Piece p=getPieceOf(num);
00116 if (!p.isPromotedNotKingGold()){
00117 pawnMask1[playerToIndex(p.owner())].set(p.position());
00118 }
00119 }
00120 }
00121 if ((pawnMask[0]!=pawnMask1[0])
00122 || (pawnMask[1]!=pawnMask1[1]))
00123 {
00124 if (showError)
00125 std::cerr << "pawnMask "
00126 << pawnMask[0] << "!=" << pawnMask1[0]
00127 << " || " << pawnMask[1] << "!=" << pawnMask1[1]
00128 << std::endl;
00129 return false;
00130 }
00131 }
00132 return true;
00133 }
00134
00135 bool osl::state::operator==(const PawnMaskState& st1,const PawnMaskState& st2)
00136 {
00137 assert(st1.isConsistent(false));
00138 assert(st2.isConsistent(false));
00139 if (st1.pawnMask[0]!=st2.pawnMask[0]) return false;
00140 if (st1.pawnMask[1]!=st2.pawnMask[1]) return false;
00141 for (int y=1;y<=9;y++)
00142 for (int x=9;x>0;x--){
00143 Piece p1=st1.getPieceOnBoard(Position(x,y));
00144 Piece p2=st2.getPieceOnBoard(Position(x,y));
00145 if (p1.ptypeO()!=p2.ptypeO()) return false;
00146 }
00147 return true;
00148
00149 }
00150
00151 std::ostream& osl::state::operator<<(std::ostream& os,const PawnMaskState& state)
00152 {
00153 os << static_cast<SimpleState>(state);
00154 return os;
00155 }
00156
00157 void osl::PawnMaskState::doSimpleMove(Position from, Position to, int promoteMask)
00158 {
00159 Piece oldPiece;
00160 int num;
00161 if(getTurn()==BLACK){
00162 apply_move::ApplyDoUndoSimpleMove<BLACK,PawnMaskState>::
00163 prologue(*this, from, to, promoteMask, oldPiece, num);
00164 }
00165 else{
00166 apply_move::ApplyDoUndoSimpleMove<WHITE,PawnMaskState>::
00167 prologue(*this, from, to, promoteMask, oldPiece, num);
00168 }
00169
00170 if (promoteMask!=0 && num<PtypeTraits<PAWN>::indexLimit)
00171 clearPawn(getTurn(), from);
00172 }
00173
00174 void osl::PawnMaskState::doDropMove(Position to,Ptype ptype)
00175 {
00176 Piece oldPiece;
00177 int num, numIndex, numLow;
00178 if(getTurn()==BLACK){
00179 apply_move::ApplyDoUndoDropMove<BLACK,PawnMaskState>::
00180 prologue(*this, ptype, to, oldPiece, num, numIndex, numLow);
00181 }
00182 else{
00183 apply_move::ApplyDoUndoDropMove<WHITE,PawnMaskState>::
00184 prologue(*this, ptype, to, oldPiece, num, numIndex, numLow);
00185 }
00186 if (ptype==PAWN)
00187 setPawn(getTurn(),to);
00188 }
00189
00190 void osl::PawnMaskState::doCaptureMove(Position from, Position to, Piece target,int promoteMask)
00191 {
00192 Piece oldPiece;
00193 int num0, num1;
00194 int num1Index;
00195 mask_t num1Mask;
00196 Ptype capturePtype;
00197 if(getTurn()==BLACK){
00198 apply_move::ApplyDoUndoCaptureMove<BLACK,PawnMaskState>::
00199 prologue(*this, from, to, target, promoteMask,
00200 capturePtype, oldPiece, num0, num1, num1Index, num1Mask);
00201 }
00202 else{
00203 apply_move::ApplyDoUndoCaptureMove<WHITE,PawnMaskState>::
00204 prologue(*this, from, to, target, promoteMask,
00205 capturePtype, oldPiece, num0, num1, num1Index, num1Mask);
00206 }
00207
00208 if (capturePtype==PAWN)
00209 clearPawn(alt(getTurn()),to);
00210 if (promoteMask!=0 && num0<PtypeTraits<PAWN>::indexLimit)
00211 clearPawn(getTurn(),from);
00212 }
00213
00214
00215 osl::apply_move::DoUndoMoveLockSimple<osl::PawnMaskState>::
00216 DoUndoMoveLockSimple(PawnMaskState& s,
00217 Position f, Position t, int promoteMask)
00218 : state(s), from(f), to(t)
00219 {
00220 if(s.getTurn()==BLACK){
00221 apply_move::ApplyDoUndoSimpleMove<BLACK,PawnMaskState>::
00222 prologue(state, from, to, promoteMask, oldPiece, num);
00223 }
00224 else{
00225 apply_move::ApplyDoUndoSimpleMove<WHITE,PawnMaskState>::
00226 prologue(state, from, to, promoteMask, oldPiece, num);
00227 }
00228 clearPawn = (promoteMask!=0) && (num < PtypeTraits<PAWN>::indexLimit);
00229 if (clearPawn)
00230 s.clearPawn(s.getTurn(),from);
00231 }
00232
00233 osl::apply_move::DoUndoMoveLockSimple<osl::PawnMaskState>::
00234 ~DoUndoMoveLockSimple()
00235 {
00236 if (clearPawn)
00237 state.setPawn(state.getTurn(),from);
00238 if(state.getTurn()==BLACK){
00239 apply_move::ApplyDoUndoSimpleMove<BLACK,PawnMaskState>::
00240 epilogue(state, from, to, oldPiece, num);
00241 }
00242 else{
00243 apply_move::ApplyDoUndoSimpleMove<WHITE,PawnMaskState>::
00244 epilogue(state, from, to, oldPiece, num);
00245 }
00246 }
00247
00248 osl::apply_move::DoUndoMoveLockDrop<osl::PawnMaskState>::
00249 DoUndoMoveLockDrop(PawnMaskState& s, Position t, Ptype ptype)
00250 : state(s), to(t)
00251 {
00252 if(state.getTurn()==BLACK){
00253 apply_move::ApplyDoUndoDropMove<BLACK,PawnMaskState>::
00254 prologue(s, ptype, to, oldPiece, num, numIndex, numLow);
00255 }
00256 else{
00257 apply_move::ApplyDoUndoDropMove<WHITE,PawnMaskState>::
00258 prologue(s, ptype, to, oldPiece, num, numIndex, numLow);
00259 }
00260 pawnDrop = (ptype==PAWN);
00261 if (pawnDrop)
00262 s.setPawn(state.getTurn(),to);
00263 }
00264
00265 osl::apply_move::DoUndoMoveLockDrop<osl::PawnMaskState>::
00266 ~DoUndoMoveLockDrop()
00267 {
00268 if (pawnDrop)
00269 state.clearPawn(state.getTurn(),to);
00270 if(state.getTurn()==BLACK){
00271 apply_move::ApplyDoUndoDropMove<BLACK,PawnMaskState>::
00272 epilogue(state, to, oldPiece, num, numIndex, numLow);
00273 }
00274 else{
00275 apply_move::ApplyDoUndoDropMove<WHITE,PawnMaskState>::
00276 epilogue(state, to, oldPiece, num, numIndex, numLow);
00277 }
00278 }
00279
00280 osl::apply_move::DoUndoMoveLockCapture<osl::PawnMaskState>::
00281 DoUndoMoveLockCapture(PawnMaskState& s,
00282 Position f, Position t, Piece tg,
00283 int promoteMask)
00284 : state(s), from(f), to(t), target(tg)
00285 {
00286 if(state.getTurn()==BLACK){
00287 apply_move::ApplyDoUndoCaptureMove<BLACK,PawnMaskState>::
00288 prologue(s, from, to, target, promoteMask,
00289 capturePtype, oldPiece, num0, num1, num1Index, num1Mask);
00290 }
00291 else{
00292 apply_move::ApplyDoUndoCaptureMove<WHITE,PawnMaskState>::
00293 prologue(s, from, to, target, promoteMask,
00294 capturePtype, oldPiece, num0, num1, num1Index, num1Mask);
00295 }
00296 pawnCapture = (capturePtype==PAWN);
00297 if (pawnCapture)
00298 s.clearPawn(alt(s.getTurn()),to);
00299 pawnPromotion = (promoteMask!=0) && (num0<PtypeTraits<PAWN>::indexLimit);
00300 if (pawnPromotion)
00301 s.clearPawn(s.getTurn(),from);
00302 }
00303 osl::apply_move::DoUndoMoveLockCapture<osl::PawnMaskState>::
00304 ~DoUndoMoveLockCapture()
00305 {
00306 if (pawnPromotion)
00307 state.setPawn(state.getTurn(), from);
00308 if (pawnCapture)
00309 state.setPawn(alt(state.getTurn()), to);
00310 if(state.getTurn()==BLACK){
00311 apply_move::ApplyDoUndoCaptureMove<BLACK,PawnMaskState>::
00312 epilogue(state, from, to, target, oldPiece, num0, num1, num1Index, num1Mask);
00313 }
00314 else{
00315 apply_move::ApplyDoUndoCaptureMove<WHITE,PawnMaskState>::
00316 epilogue(state, from, to, target, oldPiece, num0, num1, num1Index, num1Mask);
00317 }
00318 }
00319
00320
00321
00322
00323
00324