My Project
numEffectState.cc
Go to the documentation of this file.
1 /* numEffectState.cc
2  */
3 #include "osl/numEffectState.h"
4 #include "osl/numEffectState.tcc"
5 #include "osl/simpleState.tcc"
15 
16 #include <iostream>
17 #if (defined(__i386__) || defined(__x86_64__)) && !defined(OSL_NO_SSE)
18 #include <emmintrin.h>
19 typedef __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 
49 template<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++){
78  Player pl=indexToPlayer(i);
79  if(hasEffectAt(pl,p.square()))
80  {
81  effects.effected_mask[i].set(num);
82  effects.effected_changed_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();
133  if (Piece_Table.getPtypeOf(num) == Piece_Table.getPtypeOf(nump))
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 
174 bool osl::
175 NumEffectState::wasCheckEvasion(Move last_move) const
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 
232 doSimpleMove(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 }
260 doCaptureMove(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 
293 doDropMove(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 
319 template<osl::Player P>
321 prologueSimple(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 
401 epilogueSimple(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 
429 template<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 
501 template<osl::Player P>
503 epilogueDrop(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 
529 template<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 
624 template<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
663 bool 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 
734 bool 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 
818 template <bool show_error>
819 bool
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 
847 isAlmostValidMove(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
858 void 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 
884 makePinOpen(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 
901 makePinOpen(osl::Player defense)
902 {
903  pin_or_open[defense]=makePinOpen(kingSquare(defense),defense);
904 }
905 
907 allEffectAt(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;
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 
1119 findEffect(Player P, Square target, PieceVector& out) const
1120 {
1121  effect_action::StorePiece store(&out);
1122  forEachEffect(P, target, store);
1123 }
1124 
1125 namespace 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>&,
1176  const CArray<PieceMask,2>&, const CArray<uint64_t,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>&,
1182  const CArray<PieceMask,2>&, const CArray<uint64_t,2>&,
1183  const MobilityTable&);
1184  template void NumEffectState::
1186  const CArray<PieceMask,2>&, const KingMobility&, const CArray<PieceMask,2>&,
1187  const CArray<PieceMask,2>&, const CArray<uint64_t,2>&, const MobilityTable&);
1188  template void NumEffectState::
1190  const CArray<PieceMask,2>&, const KingMobility&, const CArray<PieceMask,2>&,
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
const PieceMask & piecesOnBoard(Player p) 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
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
static bool isMember(const State &state, Move m)
Definition: moveAdaptor.h:40
static bool isMember(const State &state, Move m)
Definition: moveAdaptor.h:25