My Project
numEffectState.cc
Go to the documentation of this file.
1/* numEffectState.cc
2 */
5#include "osl/simpleState.tcc"
15
16#include <iostream>
17#if (defined(__i386__) || defined(__x86_64__)) && !defined(OSL_NO_SSE)
18#include <emmintrin.h>
19typedef __v2di v2di;
20#endif
21
23 const NumEffectState& st2)
24{
25 assert(st1.isConsistent(true));
26 assert(st2.isConsistent(true));
27 if (!(st1.effects == st2.effects))
28 return false;
29 if (!(st1.pieces_onboard == st2.pieces_onboard))
30 return false;
31 if (!(st1.promoted == st2.promoted))
32 return false;
33 if (!(st1.pin_or_open == st2.pin_or_open))
34 return false;
35 if (!(st1.king_mobility == st2.king_mobility))
36 return false;
37 if (!(st1.king8infos == st2.king8infos))
38 return false;
39 return (static_cast<const SimpleState&>(st1)
40 == static_cast<const SimpleState&>(st2));
41}
42
45{
46 return King8Info(Iking8Info(king));
47}
48
49template<osl::Player P>
51{
52 const Player altP=alt(P);
53#ifdef ALLOW_KING_ABSENCE
54 if (kingSquare<P>().isPieceStand())
55 return;
56#endif
57 king8infos[P]=King8Info::make<altP>(*this,kingSquare<P>()).uint64Value();
58}
59
62 : SimpleState(st),effects(st)
63{
64 pieces_onboard[0].resetAll();
65 pieces_onboard[1].resetAll();
67 effects.effected_mask[0].resetAll();
68 effects.effected_mask[1].resetAll();
69 effects.effected_changed_mask[0].resetAll();
70 effects.effected_changed_mask[1].resetAll();
71 for(int num=0;num<40;num++){
72 Piece p=pieceOf(num);
73 if (p.isOnBoard()){
74 pieces_onboard[p.owner()].set(num);
75 if (p.isPromoted())
76 promoted.set(num);
77 for(int i=0;i<2;i++){
79 if(hasEffectAt(pl,p.square()))
80 {
81 effects.effected_mask[i].set(num);
83 }
84 }
85 }
86 }
89 if(kingSquare<BLACK>().isOnBoard())
90 makeKing8Info<BLACK>();
91 if(kingSquare<WHITE>().isOnBoard())
92 makeKing8Info<WHITE>();
93}
98
101{
102 if (! effect.any())
103 return Piece::EMPTY();
104 mask_t pieces = effect.selectBit<PAWN>(), ppieces;
105 if (pieces.any())
106 {
107 ppieces = pieces & promoted.getMask<PAWN>();
108 pieces &= ~ppieces;
109 if (pieces.any())
110 return pieceOf(pieces.bsf()+PtypeFuns<PAWN>::indexNum*32);
111 return pieceOf(ppieces.bsf()+PtypeFuns<PAWN>::indexNum*32);
112 }
113 pieces = effect.selectBit<LANCE>();
114 if (pieces.any())
115 {
116 ppieces = pieces & promoted.getMask<LANCE>();
117 pieces &= ~ppieces;
118 if (pieces.any())
119 return pieceOf(pieces.bsf()+PtypeFuns<LANCE>::indexNum*32);
120 return pieceOf(ppieces.bsf()+PtypeFuns<LANCE>::indexNum*32);
121 }
122 mask_t king = effect.selectBit<KING>();
123 effect.clearBit<KING>();
124 if (effect.none())
125 return pieceOf(king.bsf()+PtypeFuns<KING>::indexNum*32);
126 // depends on current piece numbers: <FU 0>, KE 18, GI 22, KI 26, <OU 30>, <KY 32>, KA 36, HI 38,
127 const int index = 0;
128 ppieces = effect.getMask(index) & promoted.getMask(index);
129 pieces = effect.getMask(index) & ~ppieces;
130 if (pieces.none() || ppieces.none())
131 return pieceOf(pieces.any() ? pieces.bsf() : ppieces.bsf());
132 const int num = pieces.bsf(), nump = ppieces.bsf();
134 return pieceOf(num);
135 return pieceOf(std::min(num, nump));
136}
137
140{
141 assert(! inCheck(P));
142 PieceMask pieces = piecesOnBoard(P) & effectedMask(alt(P));
143 PieceMask nolance = pieces; nolance.clearBit<LANCE>();
144 int pp=-1, npp=-1, ret=-1;
145 const int lance_index = PtypeFuns<LANCE>::indexNum; // 64bit: 0, 32bit: 1
146 for (int i=lance_index; i>=0; --i) {
147 mask_t all = nolance.getMask(i);
148 mask_t promoted = all & promotedPieces().getMask(i);
149 mask_t notpromoted = all & ~promoted;
150 if (promoted.any()) {
151 pp = promoted.bsr() + i*32;
152 notpromoted &= ~Ptype_Table.getMaskLow(Piece_Table.getPtypeOf(pp));
153 }
154 if (notpromoted.any())
155 npp = notpromoted.bsr() + i*32;
156 ret = std::max(pp, npp);
158 return pieceOf(ret);
159 }
160 mask_t lance = pieces.selectBit<LANCE>();
161 if (lance.any()) {
162 mask_t plance = lance & promotedPieces().getMask(lance_index);
163 if (plance.any())
164 return pieceOf(plance.bsr()+lance_index*32);
165 return pieceOf(lance.bsr()+lance_index*32);
166 }
167 if (ret >= 0) {
168 assert(Piece_Table.getPtypeOf(ret) == PAWN);
169 return pieceOf(ret);
170 }
171 return Piece::EMPTY();
172}
173
176{
177 if (! last_move.isNormal())
178 return false;
179 const Square from = last_move.from(), to = last_move.to();
180 if (last_move.ptype() == KING) {
181 if (last_move.isCapture()
182 && hasEffectIf(last_move.capturePtypeO(), to, from))
183 return true;
184 return hasEffectAt(turn(), from);
185 }
186 if (last_move.isCapture())
187 return hasEffectIf(last_move.capturePtypeO(), to,
188 kingSquare(alt(turn())))
189 && !Board_Table.isBetweenSafe(from, to,
190 kingSquare(alt(turn())));
191 const Piece piece = pieceOnBoard(to);
192 if (! pin(alt(turn())).test(piece.number()))
193 return false;
194 if (last_move.isDrop() || last_move.oldPtype() == KNIGHT)
195 return true;
196 const Direction d=pinnedDir(piece);
197 return primDir(d)
198 !=primDirUnsafe(Board_Table.getShort8Unsafe(piece.owner(), from,to));
199}
200
202{
203 assert(turn() == move.player());
204 if (move.isPass()) {
205 makeMovePass();
206 return;
207 }
208
209 assert(isAlmostValidMove(move));
210 const Square from=move.from();
211 const Square to=move.to();
212 if (from.isPieceStand())
213 {
214 doDropMove(to,move.ptype());
215 }
216 else
217 {
218 const Piece captured = pieceOnBoard(to);
219 if (captured != Piece::EMPTY())
220 {
221 doCaptureMove(from,to,captured,move.promoteMask());
222 }
223 else
224 {
225 doSimpleMove(from,to,move.promoteMask());
226 }
227 }
228 changeTurn();
229}
230
232doSimpleMove(Square from, Square to, int promoteMask)
233{
234 Piece oldPiece;
235 int num;
236 PtypeO oldPtypeO, newPtypeO;
237 CArray<PieceMask,2> pin_or_open_backup;
238 KingMobility king_mobility_backup;
239 PieceMask promoted_backup;
240 CArray<PieceMask,2> effected_mask_backup;
241 CArray<PieceMask,2> effected_changed_mask_backup;
242 CArray<uint64_t,2> king8infos_backup;
243 mobility::MobilityTable mobilityTable;
244 if (turn()==BLACK){
245 prologueSimple(Player2Type<BLACK>(), from, to, promoteMask,
246 oldPiece, num, oldPtypeO, newPtypeO,
247 pin_or_open_backup, king_mobility_backup,
248 promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
249 }
250 else{
251 prologueSimple(Player2Type<WHITE>(), from, to, promoteMask,
252 oldPiece, num, oldPtypeO, newPtypeO,
253 pin_or_open_backup, king_mobility_backup,
254 promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
255 }
256 if (promoteMask!=0 && num < PtypeTraits<PAWN>::indexLimit)
257 clearPawn(turn(),from);
258}
260doCaptureMove(Square from, Square to, Piece target, int promoteMask)
261{
262 Piece oldPiece;
263 PtypeO oldPtypeO, capturePtypeO, newPtypeO;
264 int num0, num1, num1Index;
265 mask_t num1Mask;
266 CArray<PieceMask,2> pin_or_open_backup;
267 KingMobility king_mobility_backup;
268 PieceMask promoted_backup;
269 CArray<PieceMask,2> effected_mask_backup;
270 CArray<PieceMask,2> effected_changed_mask_backup;
271 CArray<uint64_t,2> king8infos_backup;
272 mobility::MobilityTable mobilityTable;
273 if(turn()==BLACK){
274 prologueCapture(Player2Type<BLACK>(), from, to, target, promoteMask, oldPiece, oldPtypeO,
275 capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask,
276 pin_or_open_backup, king_mobility_backup,
277 promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
278 }
279 else{
280 prologueCapture(Player2Type<WHITE>(), from, to, target, promoteMask, oldPiece, oldPtypeO,
281 capturePtypeO, newPtypeO, num0, num1, num1Index,num1Mask,
282 pin_or_open_backup, king_mobility_backup,
283 promoted_backup, effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
284 }
285 const Ptype capturePtype=target.ptype();
286 if (capturePtype==PAWN)
287 clearPawn(alt(turn()),to);
288 if (promoteMask!=0 && num0<PtypeTraits<PAWN>::indexLimit)
289 clearPawn(turn(),from);
290}
291
293doDropMove(Square to,Ptype ptype)
294{
295 Piece oldPiece;
296 PtypeO ptypeO;
297 int num, numIndex;
298 mask_t numMask;
299 CArray<PieceMask,2> pin_or_open_backup;
300 KingMobility king_mobility_backup;
301 CArray<PieceMask,2> effected_mask_backup;
302 CArray<PieceMask,2> effected_changed_mask_backup;
303 CArray<uint64_t,2> king8infos_backup;
304 mobility::MobilityTable mobilityTable;
305 if(turn()==BLACK){
306 prologueDrop(Player2Type<BLACK>(), to, ptype, oldPiece, num, ptypeO, numIndex, numMask,
307 pin_or_open_backup, king_mobility_backup,
308 effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
309 }
310 else{
311 prologueDrop(Player2Type<WHITE>(), to, ptype, oldPiece, num, ptypeO, numIndex, numMask,
312 pin_or_open_backup, king_mobility_backup,
313 effected_mask_backup, effected_changed_mask_backup,king8infos_backup,mobilityTable);
314 }
315 if (ptype==PAWN)
316 setPawn(turn(),to);
317}
318
319template<osl::Player P>
321prologueSimple(Player2Type<P>, Square from, Square to, int promoteMask,
322 Piece& oldPiece, int& num,
323 PtypeO& oldPtypeO, PtypeO& new_ptypeo,
324 CArray<PieceMask,2>& pin_or_open_backup,
325 KingMobility& king_mobility_backup,
326 PieceMask& promoted_backup,
327 CArray<PieceMask,2>& effected_mask_backup,
328 CArray<PieceMask,2>& effected_changed_mask_backup,
329 CArray<uint64_t,2>& king8infos_backup,
330 MobilityTable &mobility_backup)
331{
332 mobility_backup = effects.mobilityTable;
333 pin_or_open_backup = pin_or_open;
334 king_mobility_backup = king_mobility;
335 effected_mask_backup = effects.effected_mask;
336 effected_changed_mask_backup = effects.effected_changed_mask;
337 king8infos_backup=king8infos;
338
339 oldPiece=pieceAt(from);
340 Piece newPiece=oldPiece.promoteWithMask(promoteMask);
341 newPiece+=(to-from);
342 num=oldPiece.number();
343
344 oldPtypeO=oldPiece.ptypeO();
345 new_ptypeo=newPiece.ptypeO();
346 // 自分自身の効きを外す
347 setPieceOf(num,newPiece);
348 effects.clearChangedEffects();
349 effects.clearEffectedChanged();
350 effects.template doEffect<NumBitmapEffect::Sub,true>(*this,oldPtypeO,from,num);
351 // 自分自身がブロックしていたpromote?の延長
352 // あるいは自分自身のブロック
353 effects.effectedNumTable[num].clear();
354 setBoard(to,newPiece);
355 effects.template doBlockAt<NumBitmapEffect::Sub,true>(*this,to,num);
356 setBoard(from,Piece::EMPTY());
357 effects.template doBlockAt<NumBitmapEffect::Add,true>(*this,from,num);
358 effects.template doEffect<NumBitmapEffect::Add,true>(*this,new_ptypeo,to,num);
359
360 if (oldPtypeO == newPtypeO(P,KING))
361 makePinOpen(P);
362 else {
363 Direction lastD=UL;
364 pin_or_open[P].reset(num);
365 recalcPinOpen(from,lastD,P);
366 recalcPinOpen(to,lastD,P);
367 }
368 {
369 Direction lastD=UL;
370 pin_or_open[alt(P)].reset(num);
371 recalcPinOpen(from,lastD,alt(P));
372 recalcPinOpen(to,lastD,alt(P));
373 }
374 promoted_backup = promoted;
375 if (promoteMask)
376 promoted.set(num);
377 if(hasEffectAt(BLACK,to))
378 effects.effected_mask[BLACK].set(num);
379 else
380 effects.effected_mask[BLACK].reset(num);
381 if(hasEffectAt(WHITE,to))
382 effects.effected_mask[WHITE].set(num);
383 else
384 effects.effected_mask[WHITE].reset(num);
385 effects.effected_changed_mask[BLACK].set(num);
386 effects.effected_changed_mask[WHITE].set(num);
387 {
388 BoardMask changed=changedEffects(BLACK)|changedEffects(WHITE);
389 changed.set(from);
390 changed.set(to);
391 if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<BLACK>()))
392 || pin_or_open[BLACK]!=pin_or_open_backup[BLACK])
393 makeKing8Info<BLACK>();
394 if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<WHITE>()))
395 || pin_or_open[WHITE]!=pin_or_open_backup[WHITE])
396 makeKing8Info<WHITE>();
397 }
398}
399
401epilogueSimple(Square from, Square to, Piece oldPiece,
402 int num, PtypeO oldPtypeO, PtypeO newPtypeO,
403 const CArray<PieceMask,2>& pin_or_open_backup,
404 const KingMobility& king_mobility_backup,
405 const PieceMask& promoted_backup,
406 const CArray<PieceMask,2>& effected_mask_backup,
407 const CArray<PieceMask,2>& effected_changed_mask_backup,
408 const CArray<uint64_t,2>& king8infos_backup,
409 const MobilityTable & mobility_backup)
410{
411 setPieceOf(num,oldPiece);
412 effects.doEffect<NumBitmapEffect::Sub,false>(*this,newPtypeO,to,num);
413 setBoard(from,oldPiece);
414 effects.effectedNumTable[num].clear();
415 effects.doBlockAt<NumBitmapEffect::Sub,false>(*this,from,num);
416 setBoard(to,Piece::EMPTY());
417 effects.doBlockAt<NumBitmapEffect::Add,false>(*this,to,num);
418 effects.doEffect<NumBitmapEffect::Add,false>(*this,oldPtypeO,from,num);
419 effects.invalidateChangedEffects();
420 pin_or_open = pin_or_open_backup;
421 king_mobility = king_mobility_backup;
422 promoted = promoted_backup;
423 effects.effected_mask = effected_mask_backup;
424 effects.effected_changed_mask = effected_changed_mask_backup;
425 effects.mobilityTable = mobility_backup;
426 king8infos = king8infos_backup;
427}
428
429template<osl::Player P>
432 Piece& oldPiece, int& num, PtypeO& ptypeO,
433 int& numIndex, mask_t& numMask,
434 CArray<PieceMask,2>& pin_or_open_backup,
435 KingMobility& king_mobility_backup,
436 CArray<PieceMask,2>& effected_mask_backup,
437 CArray<PieceMask,2>& effected_changed_mask_backup,
438 CArray<uint64_t,2>& king8infos_backup,
439 MobilityTable &mobility_backup)
440{
441 king8infos_backup = king8infos;
442 mobility_backup = effects.mobilityTable;
443 pin_or_open_backup = pin_or_open;
444 king_mobility_backup = king_mobility;
445 effected_mask_backup = effects.effected_mask;
446 effected_changed_mask_backup = effects.effected_changed_mask;
447#if OSL_WORDSIZE == 64
448 numIndex=0;
449#elif OSL_WORDSIZE == 32
450 numIndex=Ptype_Table.getIndex(ptype);
451#endif
452 const mask_t ownMochigoma=
453 standMask(P).getMask(numIndex) & Ptype_Table.getMaskLow(ptype);
454 assert(ownMochigoma.any());
455 numMask=ownMochigoma.lowestBit();
456 int numLow = ownMochigoma.bsf();
457 num = numLow|(numIndex<<5);
458 oldPiece=pieceOf(num);
459 Piece newPiece=oldPiece;
460 newPiece+=to-Square::STAND();
461 ptypeO=newPiece.ptypeO();
462 setPieceOf(num,newPiece);
463 effects.clearChangedEffects();
464 effects.clearEffectedChanged();
465 effects.template doBlockAt<NumBitmapEffect::Sub,true>(*this,to,num);
466 effects.template doEffect<NumBitmapEffect::Add,true>(*this,ptypeO,to,num);
467 setBoard(to,newPiece);
468 standMask(P).xorMask(numIndex,numMask);
469 stand_count[P][ptype-PTYPE_BASIC_MIN]--;
470 pieces_onboard[P].xorMask(numIndex,numMask);
471 {
472 Direction lastD=UL;
473 recalcPinOpen(to,lastD,P);
474 }
475 {
476 Direction lastD=UL;
477 recalcPinOpen(to,lastD,alt(P));
478 }
479 if(hasEffectAt(BLACK,to))
480 effects.effected_mask[BLACK].set(num);
481 else
482 effects.effected_mask[BLACK].reset(num);
483 if (hasEffectAt(WHITE,to))
484 effects.effected_mask[WHITE].set(num);
485 else
486 effects.effected_mask[WHITE].reset(num);
487 effects.effected_changed_mask[BLACK].set(num);
488 effects.effected_changed_mask[WHITE].set(num);
489 {
490 BoardMask changed=changedEffects(BLACK)|changedEffects(WHITE);
491 changed.set(to);
492 if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<BLACK>()))
493 || pin_or_open[BLACK]!=pin_or_open_backup[BLACK])
494 makeKing8Info<BLACK>();
495 if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<WHITE>()))
496 || pin_or_open[WHITE]!=pin_or_open_backup[WHITE])
497 makeKing8Info<WHITE>();
498 }
499}
500
501template<osl::Player P>
503epilogueDrop(Player2Type<P>, Square to, Ptype ptype, Piece oldPiece,
504 int num, PtypeO ptypeO, int numIndex, mask_t numMask,
505 const CArray<PieceMask,2>& pin_or_open_backup,
506 const KingMobility& king_mobility_backup,
507 const CArray<PieceMask,2>& effected_mask_backup,
508 const CArray<PieceMask,2>& effected_changed_mask_backup,
509 const CArray<uint64_t,2>& king8infos_backup,
510 const MobilityTable& mobility_backup)
511{
512 standMask(P).xorMask(numIndex,numMask);
513 stand_count[P][ptype-PTYPE_BASIC_MIN]++;
514 pieces_onboard[P].xorMask(numIndex,numMask);
515 setBoard(to,Piece::EMPTY());
516 effects.template doEffect<NumBitmapEffect::Sub,false>(*this,ptypeO,to,num);
517 effects.template doBlockAt<NumBitmapEffect::Add,false>(*this,to,num);
518 setPieceOf(num,oldPiece);
519 effects.effectedNumTable[num].clear();
520 effects.invalidateChangedEffects();
521 pin_or_open = pin_or_open_backup;
522 king_mobility = king_mobility_backup;
523 effects.effected_mask = effected_mask_backup;
524 effects.effected_changed_mask = effected_changed_mask_backup;
525 effects.mobilityTable = mobility_backup;
526 king8infos = king8infos_backup;
527}
528
529template<osl::Player P>
532 int promoteMask,
533 Piece& oldPiece, PtypeO& oldPtypeO, PtypeO& capturePtypeO,
534 PtypeO& new_ptypeo, int& num0, int& num1,
535 int& num1Index, mask_t& num1Mask,
536 CArray<PieceMask,2>& pin_or_open_backup,
537 KingMobility& king_mobility_backup,
538 PieceMask& promoted_backup,
539 CArray<PieceMask,2>& effected_mask_backup,
540 CArray<PieceMask,2>& effected_changed_mask_backup,
541 CArray<uint64_t,2>& king8infos_backup,
542 MobilityTable &mobility_backup)
543{
544 mobility_backup = effects.mobilityTable;
545 pin_or_open_backup = pin_or_open;
546 king_mobility_backup = king_mobility;
547 effected_mask_backup = effects.effected_mask;
548 effected_changed_mask_backup = effects.effected_changed_mask;
549 king8infos_backup = king8infos;
550
551 num1=target.number();
552 num1Index=PieceMask::numToIndex(num1);
553 num1Mask=PieceMask::numToMask(num1);
554 pieces_onboard[alt(P)].xorMask(num1Index,num1Mask);
555 standMask(P).xorMask(num1Index,num1Mask);
556 oldPiece=pieceAt(from);
557 Piece newPiece=oldPiece.promoteWithMask(promoteMask);
558 newPiece+=(to-from);
559 num0=oldPiece.number();
560 setPieceOf(num0,newPiece);
561 setPieceOf(num1,target.captured());
562
563 oldPtypeO=oldPiece.ptypeO();
564 new_ptypeo=newPiece.ptypeO();
565 capturePtypeO=target.ptypeO();
566 stand_count[P][unpromote(getPtype(capturePtypeO))-PTYPE_BASIC_MIN]++;
567 effects.clearChangedEffects();
568 effects.clearEffectedChanged();
569 effects.setChangedPieces(effectSetAt(to));
570 effects.template doEffect<NumBitmapEffect::Sub,true>(*this,capturePtypeO,to,num1);
571 effects.template doEffect<NumBitmapEffect::Sub,true>(*this,oldPtypeO,from,num0);
572 setBoard(from,Piece::EMPTY());
573 effects.template doBlockAt<NumBitmapEffect::Add,true>(*this,from,num0);
574 effects.effectedNumTable[num0]=effects.effectedNumTable[num1];
575 effects.effectedNumTable[num1].clear();
576 setBoard(to,newPiece);
577 effects.template doEffect<NumBitmapEffect::Add,true>(*this,new_ptypeo,to,num0);
578
579 if (oldPtypeO == newPtypeO(P,KING))
580 makePinOpen(P);
581 else {
582 Direction lastD=UL;
583 pin_or_open[P].reset(num0);
584 pin_or_open[P].reset(num1); // captured is not pin
585 recalcPinOpen(from,lastD,P);
586 recalcPinOpen(to,lastD,P);
587 }
588 {
589 Direction lastD=UL;
590 pin_or_open[alt(P)].reset(num0);
591 pin_or_open[alt(P)].reset(num1); // captured is not pin
592 recalcPinOpen(from,lastD,alt(P));
593 recalcPinOpen(to,lastD,alt(P));
594 }
595 promoted_backup = promoted;
596 promoted.reset(num1);
597 effects.effected_mask[BLACK].reset(num1);
598 effects.effected_mask[WHITE].reset(num1);
599 if (promoteMask)
600 promoted.set(num0);
601 if(hasEffectAt(BLACK,to))
602 effects.effected_mask[BLACK].set(num0);
603 else
604 effects.effected_mask[BLACK].reset(num0);
605 if(hasEffectAt(WHITE,to))
606 effects.effected_mask[WHITE].set(num0);
607 else
608 effects.effected_mask[WHITE].reset(num0);
609 effects.effected_changed_mask[BLACK].set(num0);
610 effects.effected_changed_mask[WHITE].set(num0);
611 {
612 BoardMask changed=changedEffects(BLACK)|changedEffects(WHITE);
613 changed.set(from);
614 changed.set(to);
615 if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<BLACK>()))
616 || pin_or_open[BLACK]!=pin_or_open_backup[BLACK])
617 makeKing8Info<BLACK>();
618 if(changed.anyInRange(Board_Mask_Table3x3.mask(kingSquare<WHITE>()))
619 || pin_or_open[WHITE]!=pin_or_open_backup[WHITE])
620 makeKing8Info<WHITE>();
621 }
622}
623
624template<osl::Player P>
627 Piece oldPiece, PtypeO oldPtypeO, PtypeO capturePtypeO,
628 PtypeO newPtypeO, int num0, int num1,
629 int num1Index, mask_t num1Mask,
630 const CArray<PieceMask,2>& pin_or_open_backup,
631 const KingMobility& king_mobility_backup,
632 const PieceMask& promoted_backup,
633 const CArray<PieceMask,2>& effected_mask_backup,
634 const CArray<PieceMask,2>& effected_changed_mask_backup,
635 const CArray<uint64_t,2>& king8infos_backup,
636 const MobilityTable &mobility_backup)
637{
638 standMask(P).xorMask(num1Index,num1Mask);
639 stand_count[P][unpromote(getPtype(capturePtypeO))-PTYPE_BASIC_MIN]--;
640 pieces_onboard[alt(P)].xorMask(num1Index,num1Mask);
641 effects.effectedNumTable[num1]=effects.effectedNumTable[num0];
642 effects.effectedNumTable[num0].clear();
643 setPieceOf(num0,oldPiece);
644 setPieceOf(num1,target);
645 effects.template doEffect<NumBitmapEffect::Sub,false>(*this,newPtypeO,to,num0);
646 setBoard(from,oldPiece);
647 setBoard(to,target);
648 effects.template doBlockAt<NumBitmapEffect::Sub,false>(*this,from,num0);
649 effects.template doEffect<NumBitmapEffect::Add,false>(*this,capturePtypeO,to,num1);
650 effects.template doEffect<NumBitmapEffect::Add,false>(*this,oldPtypeO,from,num0);
651 effects.invalidateChangedEffects();
652 pin_or_open = pin_or_open_backup;
653 king_mobility = king_mobility_backup;
654 promoted = promoted_backup;
655 effects.effected_mask = effected_mask_backup;
656 effects.effected_changed_mask = effected_changed_mask_backup;
657 effects.mobilityTable = mobility_backup;
658 king8infos = king8infos_backup;
659}
660
661
662#ifndef MINIMAL
663bool osl::NumEffectState::isConsistent(bool showError) const
664{
665 if (!SimpleState::isConsistent(showError))
666 {
667 if (showError)
668 std::cerr << "error before effect\n";
669 return false;
670 }
671 effect::NumSimpleEffectTable effects1(*this);
672 if (!(effects1==effects))
673 {
674 if (showError)
675 {
676 std::cerr << "Effect error 1" << std::endl;
677 std::cerr << *this;
678 for(int y=1;y<=9;y++)
679 for(int x=9;x>0;x--)
680 {
681 Square pos(x,y);
682 if (!(effects1.effectSetAt(pos)==effects.effectSetAt(pos)))
683 {
684 std::cerr << pos << ",real=" << effects.effectSetAt(pos) << ",ideal=" << effects1.effectSetAt(pos) << std::endl;
685 }
686 }
687 for(int num=0;num<=39;num++){
688 for(int i=0;i<8;i++){
689 Direction d=static_cast<Direction>(i);
690 if(effects.effectedNumTable[num][d]!=effects1.effectedNumTable[num][d]){
691 std::cerr << "piece=" << pieceOf(num) << ",num=" << num << ",d=" << d << ",v1=" << effects.effectedNumTable[num][d] << ",v2=" << effects1.effectedNumTable[num][d] << std::endl;
692 }
693 }
694 }
695 std::cerr << effects.effectedNumTable << std::endl;
696 }
697 return false;
698 }
699 for (int z=0; z<2; ++z) {
700 const Player p = indexToPlayer(z);
701#ifdef ALLOW_KING_ABSENCE
702 if (kingSquare(p).isPieceStand())
703 continue;
704#endif
705#if 0
706 const PieceMask pin2 = effect_util::Pin::make(*this, p);
707 if (pin(p) != pin2) {
708 if (showError)
709 std::cerr << "pin for " << p << " differs " << pin(p) << " " << pin2 << "\n";
710 return false;
711 }
712#endif
713 King8Info king8info2 = King8Info::make(alt(p), *this);
714 if (King8Info(Iking8Info(p)).uint64Value() != king8info2.uint64Value()) {
715 if (showError)
716 std::cerr << "king8info for " << p << " differs \n" << King8Info(Iking8Info(p)) << "\n" << king8info2 << "\n";
717 return false;
718 }
719 }
720 for (int i=0; i<Piece::SIZE; ++i) {
721 const Piece p = pieceOf(i);
722 if (p.isOnBoard()) {
723 if (promoted.test(i) != p.isPromoted()) {
724 if (showError)
725 std::cerr << "promoted differs " << p << " " << promoted << " " << promoted.test(i) << "\n";
726 return false;
727 }
728 }
729 }
730 return true;
731}
732#endif
733
734bool osl::NumEffectState::isConsistent(const NumEffectState& prev, Move moved, bool show_error) const
735{
736 // test changedEffects
737 const CArray<BoardMask,2> changed_squares
738 = {{ changedEffects(BLACK), changedEffects(WHITE) }};
739 const BoardMask changed_all = changed_squares[BLACK] | changed_squares[WHITE];
740 CArray<BoardMask, Piece::SIZE> each_effect, prev_effect;
741 for (int i=0; i<Piece::SIZE; ++i) {
742 each_effect[i].clear();
743 prev_effect[i].clear();
744 }
745 for (int x=1; x<=9; ++x) {
746 for (int y=1; y<=9; ++y) {
747 const Square sq(x, y);
748 for (int i=0; i<Piece::SIZE; ++i) {
749 if (effectSetAt(sq).test(i))
750 each_effect[i].set(sq);
751 if (prev.effectSetAt(sq).test(i))
752 prev_effect[i].set(sq);
753 }
754 if (! changed_all.test(sq))
755 {
756 if (effectSetAt(sq) != prev.effectSetAt(sq)) {
757#ifndef MINIMAL
758 if (show_error)
759 std::cerr << "changedEffects unset\n" << *this << moved << sq << "\n";
760#endif
761 return false;
762 }
763 }
764 for (int i=0; i<2; ++i)
765 {
766 const Player pl = indexToPlayer(i);
767 if (! changed_squares[pl].test(sq))
768 {
769 if ((effectSetAt(sq) & piecesOnBoard(pl))
770 != (prev.effectSetAt(sq) & prev.piecesOnBoard(pl))) {
771#ifndef MINIMAL
772 if (show_error)
773 std::cerr << "changedEffects unset for " << pl << "\n" << *this << moved << sq << "\n";
774#endif
775 return false;
776 }
777 }
778 }
779 }
780 }
781 // test changedPieces()
782 const NumBitmapEffect changed_effect_pieces = changedPieces();
783 for (int i=0; i<Piece::SIZE; ++i) {
784 if (each_effect[i] == prev_effect[i])
785 continue;
786 if (! changed_effect_pieces.test(i)) {
787#ifndef MINIMAL
788 if (show_error)
789 std::cerr << "changedPieces() unset\n" << *this << moved << i
790 << " " << each_effect[i] << " != " << prev_effect[i] << "\n";
791#endif
792 return false;
793 }
794 }
795 // test effectedChanged(Player pl)
796 for (int i=0; i<Piece::SIZE; ++i)
797 {
798 for (int j=0; j<2; ++j)
799 {
800 const Player pl = indexToPlayer(j);
801 if (prev.pieceOf(i).square() == moved.to())
802 continue; // captured
803 if (prev.effectedMask(pl).test(i) != effectedMask(pl).test(i)) {
804 if (! effectedChanged(pl).test(i)) {
805#ifndef MINIMAL
806 if (show_error)
807 std::cerr << "effectedChanged(" << pl << ") unset\n" << *this << moved << i
808 << " " << prev.effectedChanged(pl) << " != " << prev.effectedChanged(WHITE) << "\n";
809#endif
810 return false;
811 }
812 }
813 }
814 }
815 return true;
816}
817
818template <bool show_error>
819bool
820#if (defined __GNUC__) && (! defined GPSONE) && (! defined GPSUSIONE)
821__attribute__ ((used,noinline))
822#endif
824 assert(move.isValid());
825 assert(move.isNormal());
826 assert(this->turn() == move.player());
827 assert(isValidMoveByRule(move, true));
828
829 const Square from=move.from();
830 if (from.isPieceStand()) // 打つ手
831 return isAlmostValidDrop<show_error>(move);
832 const Square to=move.to();
833 const Piece from_piece = this->pieceAt(from);
834
835 if (! testValidityOtherThanEffect<show_error>(move))
836 return false;
837 if(!hasEffectByPiece(from_piece,to)){
838 if (show_error) {
839 std::cerr << " No such move2 : " << move << std::endl;
840 }
841 return false;
842 }
843 return true;
844}
845
847isAlmostValidMove(Move move,bool show_error) const{
848#ifdef MINIMAL
849 show_error=false;
850#endif
851 if(show_error)
852 return isAlmostValidMove<true>(move);
853 else
854 return isAlmostValidMove<false>(move);
855}
856
857#ifndef MINIMAL
858void osl::NumEffectState::showEffect(std::ostream& os) const
859{
860 os<< static_cast<SimpleState const&>(*this);
861 for(int y=1;y<=9;y++){
862 os << 'P' << y;
863 for(int x=9;x>0;x--){
864 Square pos(x,y);
865 os << csa::show(pieceAt(pos)) << effectSetAt(pos);
866 }
867 os << std::endl;
868 }
869 // 持ち駒の表示
870 for(int num=0;num<Piece::SIZE;num++){
871 if (standMask(BLACK).test(num)){
872 os << "P+00" << csa::show(Piece_Table.getPtypeOf(num))
873 << std::endl;
874 }
875 else if (standMask(WHITE).test(num)){
876 os << "P-00" << csa::show(Piece_Table.getPtypeOf(num))
877 << std::endl;
878 }
879 }
880}
881#endif
882
884makePinOpen(osl::Square target,osl::Player defense)
885{
886 PieceMask pins;
887 if(target.isPieceStand()) return pins;
888 PieceMask mask=piecesOnBoard(alt(defense));
889 makePinOpenDir<UL>(target,pins,mask,defense);
890 makePinOpenDir<U>(target,pins,mask,defense);
891 makePinOpenDir<UR>(target,pins,mask,defense);
892 makePinOpenDir<L>(target,pins,mask,defense);
893 makePinOpenDir<R>(target,pins,mask,defense);
894 makePinOpenDir<DL>(target,pins,mask,defense);
895 makePinOpenDir<D>(target,pins,mask,defense);
896 makePinOpenDir<DR>(target,pins,mask,defense);
897 return pins;
898}
899
902{
903 pin_or_open[defense]=makePinOpen(kingSquare(defense),defense);
904}
905
906const osl::mask_t osl::NumEffectState::
907allEffectAt(Player attack, Ptype ptype, Square target) const
908{
909 switch (ptype) {
910 case PAWN: case PPAWN:
911 return allEffectAt<PAWN>(attack, target);
912 case LANCE: case PLANCE:
913 return allEffectAt<LANCE>(attack, target);
914 case KNIGHT: case PKNIGHT:
915 return allEffectAt<KNIGHT>(attack, target);
916 case SILVER: case PSILVER:
917 return allEffectAt<SILVER>(attack, target);
918 case GOLD:
919 return allEffectAt<GOLD>(attack, target);
920 case BISHOP: case PBISHOP:
921 return allEffectAt<BISHOP>(attack, target);
922 case ROOK: case PROOK:
923 return allEffectAt<ROOK>(attack, target);
924 case KING:
925 return allEffectAt<KING>(attack, target);
926 default:
927 assert(0);
928 }
929 return mask_t();
930}
931
933{
934#ifndef MINIMAL
935 (*this).used_mask=src.used_mask;
936#endif
937 (*this).stand_mask=src.stand_mask;
938#if (defined(__i386__) || defined(__x86_64__)) && !defined(OSL_NO_SSE)
939 {
940 v2di b16=*((v2di*)&src.board[16]);
941 v2di b20=*((v2di*)&src.board[20]);
942 v2di b24=*((v2di*)&src.board[24]);
943 v2di b32=*((v2di*)&src.board[32]);
944 v2di b36=*((v2di*)&src.board[36]);
945 v2di b40=*((v2di*)&src.board[40]);
946 v2di b48=*((v2di*)&src.board[48]);
947 v2di b52=*((v2di*)&src.board[52]);
948 v2di b56=*((v2di*)&src.board[56]);
949
950 *((v2di*)&(*this).board[16])=b16;
951 *((v2di*)&(*this).board[20])=b20;
952 *((v2di*)&(*this).board[24])=b24;
953 *((v2di*)&(*this).board[32])=b32;
954 *((v2di*)&(*this).board[36])=b36;
955 *((v2di*)&(*this).board[40])=b40;
956 *((v2di*)&(*this).board[48])=b48;
957 *((v2di*)&(*this).board[52])=b52;
958 *((v2di*)&(*this).board[56])=b56;
959
960
961 v2di b64=*((v2di*)&src.board[64]);
962 v2di b68=*((v2di*)&src.board[68]);
963 v2di b72=*((v2di*)&src.board[72]);
964
965 v2di b80=*((v2di*)&src.board[80]);
966 v2di b84=*((v2di*)&src.board[84]);
967 v2di b88=*((v2di*)&src.board[88]);
968
969 v2di b96=*((v2di*)&src.board[96]);
970 v2di b100=*((v2di*)&src.board[100]);
971 v2di b104=*((v2di*)&src.board[104]);
972
973
974 *((v2di*)&(*this).board[64])=b64;
975 *((v2di*)&(*this).board[68])=b68;
976 *((v2di*)&(*this).board[72])=b72;
977
978 *((v2di*)&(*this).board[80])=b80;
979 *((v2di*)&(*this).board[84])=b84;
980 *((v2di*)&(*this).board[88])=b88;
981
982 *((v2di*)&(*this).board[96])=b96;
983 *((v2di*)&(*this).board[100])=b100;
984 *((v2di*)&(*this).board[104])=b104;
985
986 v2di b112=*((v2di*)&src.board[112]);
987 v2di b116=*((v2di*)&src.board[116]);
988 v2di b120=*((v2di*)&src.board[120]);
989
990 v2di b128=*((v2di*)&src.board[128]);
991 v2di b132=*((v2di*)&src.board[132]);
992 v2di b136=*((v2di*)&src.board[136]);
993
994 v2di b144=*((v2di*)&src.board[144]);
995 v2di b148=*((v2di*)&src.board[148]);
996 v2di b152=*((v2di*)&src.board[152]);
997
998 *((v2di*)&(*this).board[112])=b112;
999 *((v2di*)&(*this).board[116])=b116;
1000 *((v2di*)&(*this).board[120])=b120;
1001
1002 *((v2di*)&(*this).board[128])=b128;
1003 *((v2di*)&(*this).board[132])=b132;
1004 *((v2di*)&(*this).board[136])=b136;
1005
1006 *((v2di*)&(*this).board[144])=b144;
1007 *((v2di*)&(*this).board[148])=b148;
1008 *((v2di*)&(*this).board[152])=b152;
1009
1010 v2di p0=*((v2di*)&src.pieces[0]);
1011 v2di p4=*((v2di*)&src.pieces[4]);
1012 v2di p8=*((v2di*)&src.pieces[8]);
1013 v2di p12=*((v2di*)&src.pieces[12]);
1014 v2di p16=*((v2di*)&src.pieces[16]);
1015 v2di p20=*((v2di*)&src.pieces[20]);
1016 v2di p24=*((v2di*)&src.pieces[24]);
1017 v2di p28=*((v2di*)&src.pieces[28]);
1018 v2di p32=*((v2di*)&src.pieces[32]);
1019 v2di p36=*((v2di*)&src.pieces[36]);
1020 *((v2di*)&(*this).pieces[0])=p0;
1021 *((v2di*)&(*this).pieces[4])=p4;
1022 *((v2di*)&(*this).pieces[8])=p8;
1023 *((v2di*)&(*this).pieces[12])=p12;
1024 *((v2di*)&(*this).pieces[16])=p16;
1025 *((v2di*)&(*this).pieces[20])=p20;
1026 *((v2di*)&(*this).pieces[24])=p24;
1027 *((v2di*)&(*this).pieces[28])=p28;
1028 *((v2di*)&(*this).pieces[32])=p32;
1029 *((v2di*)&(*this).pieces[36])=p36;
1030 }
1031#else
1032 for(int x=1;x<=9;x++)
1033 for(int y=1;y<=9;y++)
1034 (*this).board[Square(x,y).index()]=src.board[Square(x,y).index()];
1035 (*this).pieces=src.pieces;
1036#endif
1037 (*this).pawnMask=src.pawnMask;
1038 this->stand_count = src.stand_count;
1039 this->player_to_move=src.player_to_move;
1040 effects.copyFrom(src.effects);
1041 this->pieces_onboard=src.pieces_onboard;
1042 (*this).promoted=src.promoted;
1043 (*this).pin_or_open=src.pin_or_open;
1044 (*this).king_mobility=src.king_mobility;
1045 (*this).king8infos=src.king8infos;
1046}
1047
1049{
1050 copyFrom(NumEffectState(src));
1051}
1052
1054{
1055 using namespace move_classifier;
1056 return ConditionAdaptor<SafeMove>::isMember(*this, move);
1057}
1059{
1060 using namespace move_classifier;
1061 return PlayerMoveAdaptor<Check>::isMember(*this, move);
1062}
1064{
1065 using namespace move_classifier;
1066 return PlayerMoveAdaptor<PawnDropCheckmate>::isMember(*this, move);
1067}
1069{
1070 using namespace move_classifier;
1071 return PlayerMoveAdaptor<DirectCheck>::isMember(*this, move);
1072}
1073
1075{
1076 using namespace move_classifier;
1077 return ConditionAdaptor<OpenCheck>::isMember(*this, move);
1078}
1079
1080#ifndef MINIMAL
1087{
1088 if (inCheck()) {
1089 // 王手がかかっている時は防ぐ手のみを生成, 王手回避は不成も生成
1090 GenerateEscapeKing::generate(*this, moves);
1091 }
1092 else {
1093 // そうでなければ全ての手を生成
1094 MoveVector all_moves;
1095 GenerateAllMoves::generate(turn(), *this, all_moves);
1096 // この指手は,玉の素抜きがあったり,打歩詰の可能性があるので
1097 // 確認が必要
1098 std::copy_if(all_moves.begin(), all_moves.end(), std::back_inserter(moves),
1099 [&](Move m){
1100 return this->isSafeMove(m) && ! this->isPawnDropCheckmate(m);
1101 });
1102 }
1103}
1104
1106{
1107 generateLegal(moves);
1108 if (inCheck())
1109 return;
1110 for (int i=0, iend=moves.size(); i<iend; ++i) {
1111 const Move move = moves[i];
1112 if (move.hasIgnoredUnpromote())
1113 moves.push_back(move.unpromote());
1114 }
1115}
1116#endif
1117
1119findEffect(Player P, Square target, PieceVector& out) const
1120{
1121 effect_action::StorePiece store(&out);
1122 forEachEffect(P, target, store);
1123}
1124
1125namespace osl
1126{
1127 // explicit template instantiation
1128
1129 template bool NumEffectState::
1130 hasEffectByWithRemove<BLACK>(Square, Square) const;
1131 template bool NumEffectState::
1132 hasEffectByWithRemove<WHITE>(Square, Square) const;
1133 template void NumEffectState::makeKing8Info<BLACK>();
1134 template void NumEffectState::makeKing8Info<WHITE>();
1135
1136
1137 template void NumEffectState::
1142 template void NumEffectState::
1147
1148 template void NumEffectState::
1150 PtypeO&, PtypeO&, PtypeO&, int&, int&, int&, mask_t&,
1154 template void NumEffectState::
1156 PtypeO&, PtypeO&, PtypeO&, int&, int&, int&, mask_t&,
1160
1161 template void NumEffectState::
1163 int&, mask_t&, CArray<PieceMask,2>&, KingMobility&,
1166 template void NumEffectState::
1168 int&, mask_t&, CArray<PieceMask,2>&, KingMobility&,
1171
1172 template void NumEffectState::
1174 PtypeO, int, int, int, mask_t, const CArray<PieceMask,2>&,
1175 const KingMobility&, const PieceMask&, const CArray<PieceMask,2>&,
1177 const MobilityTable&);
1178 template void NumEffectState::
1180 PtypeO, int, int, int, mask_t, const CArray<PieceMask,2>&,
1181 const KingMobility&, const PieceMask&, const CArray<PieceMask,2>&,
1183 const MobilityTable&);
1184 template void NumEffectState::
1188 template void NumEffectState::
1191 const CArray<PieceMask,2>&, const CArray<uint64_t,2>&, const MobilityTable&);
1192
1193#ifndef DFPNSTATONE
1194 template Piece
1195 NumEffectState::safeCaptureNotByKing<BLACK>(Square, Piece) const;
1196 template Piece
1197 NumEffectState::safeCaptureNotByKing<WHITE>(Square, Piece) const;
1198#endif
1199}
1200
1201/* ------------------------------------------------------------------------- */
1202// ;;; Local Variables:
1203// ;;; mode:c++
1204// ;;; c-basic-offset:2
1205// ;;; End:
Direction getShort8Unsafe(Square from, Square to) const
8方向にいない場合も適当なものを返す.
Definition boardTable.h:134
bool isBetweenSafe(Square t, Square p0, Square p1) const
Definition boardTable.h:179
size_t size() const
Definition container.h:243
void push_back(const T &e)
Definition container.h:204
圧縮していない moveの表現 .
bool isValid() const
Ptype ptype() const
Player player() const
bool isDrop() const
const Move unpromote() const
promote moveからunpromote moveを作る
bool isPass() const
PtypeO capturePtypeO() const
bool isNormal() const
INVALID でも PASS でもない.
int promoteMask() const
pieceに使うためのmaskなので
Ptype oldPtype() const
移動前のPtype, i.e., 成る手だった場合成る前
bool hasIgnoredUnpromote() const
MoveをunpromoteするとcutUnpromoteなMoveになる
bool isCapture() const
const Square to() const
const Square from() const
利きを持つ局面
void generateLegal(MoveVector &) const
全ての合法手を生成する.
const NumBitmapEffect effectSetAt(Square sq) const
void doCaptureMove(Square from, Square to, Piece target, int promoteMask)
const checkmate::King8Info king8Info(Player king) const
void epilogueCapture(Player2Type< P >, Square from, Square to, Piece target, Piece oldPiece, PtypeO oldPtypeO, PtypeO capturePtypeO, PtypeO newPtypeO, int num0, int num1, int num1Index, mask_t num1Mask, const CArray< PieceMask, 2 > &pin_or_open_backup, const KingMobility &king_mobility_backup, const PieceMask &promoted_backup, const CArray< PieceMask, 2 > &effected_mask_backup, const CArray< PieceMask, 2 > &effected_changed_mask_backup, const CArray< uint64_t, 2 > &king8infos_backup, const MobilityTable &mobility_backup)
bool isOpenCheck(Move move) const
CArray< PieceMask, 2 > pieces_onboard
const Piece selectCheapPiece(PieceMask effect) const
利きの中から安そうな駒を選ぶ
bool isPawnDropCheckmate(Move move) const
const PieceMask effectedMask(Player pl) const
pl からの利きが(1つ以上)ある駒一覧
void doSimpleMove(Square from, Square to, int promoteMask)
void prologueCapture(Player2Type< P >, Square from, Square to, Piece target, int promoteMask, Piece &oldPiece, PtypeO &oldPtypeO, PtypeO &capturePtypeO, PtypeO &new_ptypeo, int &num0, int &num1, int &num1Index, mask_t &num1Mask, CArray< PieceMask, 2 > &pin_or_open_backup, KingMobility &king_mobility_backup, PieceMask &promoted_backup, CArray< PieceMask, 2 > &effected_mask_backup, CArray< PieceMask, 2 > &effected_changed_mask_backup, CArray< uint64_t, 2 > &king8infos_backup, MobilityTable &mobility_backup)
bool wasCheckEvasion(Move last_move) const
void makeMove(Move move)
bool isAlmostValidMove(Move move) const
合法手かどうかを簡単に検査する.局面に依存するチェックのみ. ルール上指せない手である可能性がある場合は,isValidMove を用いる.
const PieceMask effectedChanged(Player pl) const
前の指手でeffectedMask(pl)が変化したか.
void copyFrom(const NumEffectState &src)
主要部分を高速にコピーする.
void generateAllUnsafe(MoveVector &) const
自殺を含めてすべての手を生成
PieceMask makePinOpen(Square target, Player defense)
bool isDirectCheck(Move move) const
bool hasEffectAt(Square target) const
対象とするマスにあるプレイヤーの利きがあるかどうか.
void prologueSimple(Player2Type< P >, Square from, Square to, int promoteMask, Piece &oldPiece, int &num, PtypeO &oldPtypeO, PtypeO &new_ptypeo, CArray< PieceMask, 2 > &pin_or_open_backup, KingMobility &king_mobility_backup, PieceMask &promoted_backup, CArray< PieceMask, 2 > &effected_mask_backup, CArray< PieceMask, 2 > &effected_changed_mask_backup, CArray< uint64_t, 2 > &king8infos_backup, MobilityTable &mobility_backup)
NumEffectState(const SimpleState &st=SimpleState(HIRATE))
const Piece findThreatenedPiece(Player P) const
取られそうなPの駒で価値が最大のもの
effect::NumSimpleEffectTable effects
void findEffect(Player P, Square target, PieceVector &out) const
target に利きのあるPieceをoutに格納する
PieceMask promoted
成駒一覧
void doDropMove(Square to, Ptype ptype)
void epilogueSimple(Square from, Square to, Piece oldPiece, int num, PtypeO oldPtypeO, PtypeO newPtypeO, const CArray< PieceMask, 2 > &pin_or_open_backup, const KingMobility &king_mobility_backup, const PieceMask &promoted_backup, const CArray< PieceMask, 2 > &effected_mask_backup, const CArray< PieceMask, 2 > &effected_changed_mask_backup, const CArray< uint64_t, 2 > &king8infos_backup, const MobilityTable &mobility_backup)
KingMobility king_mobility
void showEffect(std::ostream &os) const
CArray< uint64_t, 2 > king8infos
CArray< PieceMask, 2 > pin_or_open
bool isSafeMove(Move move) const
const PieceMask & piecesOnBoard(Player p) const
void epilogueDrop(Player2Type< P >, Square to, Ptype ptype, Piece oldPiece, int num, PtypeO ptypeO, int numIndex, mask_t numMask, const CArray< PieceMask, 2 > &pin_or_open_backup, const KingMobility &king_mobility_backup, const CArray< PieceMask, 2 > &effected_mask_backup, const CArray< PieceMask, 2 > &effected_changed_mask_backup, const CArray< uint64_t, 2 > &king8infos_backup, const MobilityTable &mobility_backup)
bool isConsistent(bool showError=true) const
void prologueDrop(Player2Type< P >, Square to, Ptype ptype, Piece &oldPiece, int &num, PtypeO &ptypeO, int &numIndex, mask_t &numMask, CArray< PieceMask, 2 > &pin_or_open_backup, KingMobility &king_mobility_backup, CArray< PieceMask, 2 > &effected_mask_backup, CArray< PieceMask, 2 > &effected_changed_mask_backup, CArray< uint64_t, 2 > &king8infos_backup, MobilityTable &mobility_backup)
bool isCheck(Move move) const
const mask_t allEffectAt(Player P, Square target) const
void generateWithFullUnpromotions(MoveVector &) const
打歩詰め絡み以外では有利にはならない手も含め, 全ての合法手を生成す る(Move::ignoredUnpromoteも生成する).
駒番号のビットセット.
Definition pieceMask.h:21
const mask_t getMask(int num) const
Definition pieceMask.h:59
void set(int num)
Definition pieceMask.h:48
void clearBit()
unpromote(PTYPE) の駒のbit を消す
Definition pieceMask.h:74
bool test(int num) const
Definition pieceMask.h:45
bool any() const
Definition pieceMask.h:57
static const mask_t numToMask(int num)
Definition pieceMask.h:25
const mask_t selectBit() const
unpromote(PTYPE) の駒のbit だけ取り出す
Definition pieceMask.h:66
void reset(int num)
Definition pieceMask.h:54
Ptype getPtypeOf(int num) const
Definition pieceTable.h:18
PtypeO ptypeO() const
Definition basic_type.h:824
Ptype ptype() const
Definition basic_type.h:821
bool isPromoted() const
promoteした駒かどうかをチェックする
Definition basic_type.h:898
const Square square() const
Definition basic_type.h:832
Player owner() const
Definition basic_type.h:963
const Piece promoteWithMask(int promote_mask) const
Definition basic_type.h:885
int number() const
Definition basic_type.h:828
static const Piece EMPTY()
Definition basic_type.h:797
const Piece captured() const
取られたpieceを作成.
Definition basic_type.h:879
bool isOnBoard() const
Definition basic_type.h:985
static const int SIZE
Definition basic_type.h:794
int getIndex(Ptype) const
Definition ptypeTable.h:50
mask_t getMaskLow(Ptype ptype) const
Definition ptypeTable.h:46
CArray< BitXmask, 2 > pawnMask
Definition simpleState.h:57
CArray< Piece, Square::SIZE > board
Definition simpleState.h:47
Player player_to_move
手番
Definition simpleState.h:61
CArray< CArray< char, PTYPE_SIZE-PTYPE_BASIC_MIN >, 2 > stand_count
Definition simpleState.h:58
PieceMask used_mask
Definition simpleState.h:62
bool isOnBoard(int num) const
CArray< PieceMask, 2 > stand_mask
Definition simpleState.h:56
CArray< Piece, Piece::SIZE > pieces
全てのpieceが登録されている
Definition simpleState.h:55
const Piece pieceOf(int num) const
Definition simpleState.h:76
bool isConsistent(bool show_error=true) const
unsigned int index() const
Definition basic_type.h:572
bool isPieceStand() const
Definition basic_type.h:576
static const Square STAND()
Definition basic_type.h:548
敵玉の8近傍の状態を表す.
Definition king8Info.h:29
uint64_t uint64Value() const
Definition king8Info.h:46
static const King8Info make(NumEffectState const &state, Square king, PieceMask pinned)
const BoardMask & mask(Square p) const
p中心の3x3 の範囲のbitを立てたもの, centeringなし
Definition boardMask.h:123
void set(unsigned int i)
Definition boardMask.h:40
bool test(unsigned int i) const
Definition boardMask.h:52
bool anyInRange(const BoardMask &mask) const
Definition boardMask.h:57
static int numToIndex(int)
Definition pieceMask64.h:16
現在の定義 (2005/3/4以降)
局面全体の利きデータ.
EffectedNumTable effectedNumTable
effected num
const NumBitmapEffect effectSetAt(Square pos) const
ある位置の利きデータを取り出す.
CArray< PieceMask, 2 > effected_mask
CArray< PieceMask, 2 > effected_changed_mask
駒番号からMobilityContentを得る
static void generate(const NumEffectState &state, Action &action)
const std::string show(Move)
Definition csa.cc:133
Ptype
駒の種類を4ビットでコード化する
Definition basic_type.h:84
@ ROOK
Definition basic_type.h:100
@ PPAWN
Definition basic_type.h:87
@ BISHOP
Definition basic_type.h:99
@ PROOK
Definition basic_type.h:92
@ PAWN
Definition basic_type.h:95
@ KING
Definition basic_type.h:93
@ KNIGHT
Definition basic_type.h:97
@ SILVER
Definition basic_type.h:98
@ PTYPE_BASIC_MIN
Definition basic_type.h:103
@ PKNIGHT
Definition basic_type.h:89
@ GOLD
Definition basic_type.h:94
@ PLANCE
Definition basic_type.h:88
@ PBISHOP
Definition basic_type.h:91
@ LANCE
Definition basic_type.h:96
@ PSILVER
Definition basic_type.h:90
const PtypeTable Ptype_Table
Definition tables.cc:97
Ptype getPtype(PtypeO ptypeO)
Definition basic_type.h:217
const PieceTable Piece_Table
Definition tables.cc:94
constexpr Player indexToPlayer(int n)
Definition basic_type.h:19
Ptype unpromote(Ptype ptype)
ptypeがpromote後の型の時に,promote前の型を返す. promoteしていない型の時はそのまま返す
Definition basic_type.h:157
const BoardTable Board_Table
Definition tables.cc:95
constexpr Direction primDirUnsafe(Direction d)
8方向について,primitiveな4方向を求める dとしてknight, INVALIDなども来る
Definition basic_type.h:374
Direction
Definition basic_type.h:310
Player
Definition basic_type.h:8
@ WHITE
Definition basic_type.h:10
@ BLACK
Definition basic_type.h:9
const PtypeO PTYPEO_EDGE __attribute__((unused))
PtypeO
Player + Ptype [-15, 15] PtypeO の O は Owner の O.
Definition basic_type.h:199
constexpr Direction primDir(Direction d)
8方向について,primitiveな4方向を求める
Definition basic_type.h:366
constexpr Player alt(Player player)
Definition basic_type.h:13
PtypeO newPtypeO(Player player, Ptype ptype)
Definition basic_type.h:211
PtypeO captured(PtypeO ptypeO)
unpromoteすると共に,ownerを反転する.
Definition basic_type.h:264
bool operator==(Square l, Square r)
Definition basic_type.h:758
static void generate(Player p, const NumEffectState &state, MoveVector &)
Definition allMoves.cc:15
static void generate(const NumEffectState &state, MoveVector &out)
不成の受けも作成
Definition escape_.cc:9
指手を MoveVector に保管
Definition move_action.h:16