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}
96{
97}
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
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
1082{
1083 move_action::Store store(out);
1085}
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::
1166 template void NumEffectState::
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の表現 .
Definition: basic_type.h:1052
bool isValid() const
Definition: basic_type.cc:246
Ptype ptype() const
Definition: basic_type.h:1155
Player player() const
Definition: basic_type.h:1195
bool isDrop() const
Definition: basic_type.h:1150
const Move unpromote() const
promote moveからunpromote moveを作る
Definition: basic_type.h:1243
bool isPass() const
Definition: basic_type.h:1092
PtypeO capturePtypeO() const
Definition: basic_type.h:1185
bool isNormal() const
INVALID でも PASS でもない.
Definition: basic_type.h:1088
int promoteMask() const
pieceに使うためのmaskなので
Definition: basic_type.h:1143
Ptype oldPtype() const
移動前のPtype, i.e., 成る手だった場合成る前
Definition: basic_type.h:1174
bool hasIgnoredUnpromote() const
MoveをunpromoteするとcutUnpromoteなMoveになる
Definition: basic_type.h:1309
bool isCapture() const
Definition: basic_type.h:1148
const Square to() const
Definition: basic_type.h:1132
const Square from() const
Definition: basic_type.h:1125
利きを持つ局面
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
uint64_t Iking8Info(Player king) 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
Definition: simpleState.h:176
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
Definition: simpleState.cc:157
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を得る
Definition: mobilityTable.h:52
static void generate(const NumEffectState &state, Action &action)
const BoardMaskTable3x3 Board_Mask_Table3x3
Definition: tables.cc:120
const std::string show(Move)
Definition: csa.cc:133
int max(Player p, int v1, int v2)
Definition: evalTraits.h:84
int min(Player p, int v1, int v2)
Definition: evalTraits.h:92
GeneralMask< mask_int_t > mask_t
Definition: mask.h:351
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
@ UL
Definition: basic_type.h:313
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
PieceVector に格納
指手を MoveVector に保管
Definition: move_action.h:16