My Project
majorPiece.cc
Go to the documentation of this file.
1 #include "osl/eval/majorPiece.h"
3 #include <algorithm>
4 using osl::MultiInt;
5 
6 template <bool Opening, osl::Ptype MajorBasic>
9 
10 template <bool Opening, osl::Ptype MajorBasic>
11 void osl::eval::ml::
13 {
14  for (size_t i = 0; i < weights.dimension(); ++i)
15  {
16  table[i] = weights.value(i);
17  }
18 }
19 
20 
21 template <bool Opening>
23 
24 template <bool Opening>
25 void osl::eval::ml::
27 {
28  weight = weights.value(0);
29 }
30 
31 template <bool Opening>
33 {
34  int result = 0;
35  for (int i = PtypeTraits<ROOK>::indexMin;
36  i < PtypeTraits<ROOK>::indexLimit;
37  ++i)
38  {
39  const Piece piece = state.pieceOf(i);
40  if (piece.isOnBoard() && !piece.square().canPromote(piece.owner()) &&
41  !state.isPawnMaskSet(piece.owner(), piece.square().x()))
42  {
43  if (piece.owner() == BLACK)
44  result += weight;
45  else
46  result -= weight;
47  }
48  }
49  return result;
50 }
51 
52 
58 
60 RookPawnYX::setUp(const Weights &weights)
61 {
62  for (int i = 0; i < ONE_DIM; ++i)
63  {
64  for (int s=0; s<NStages; ++s)
65  {
66  RookPawnY::y_attack_table[i][s] = weights.value(i + ONE_DIM * 2 * s);
67  RookPawnY::y_defense_table[i][s] = weights.value(i + ONE_DIM * 2 * s + ONE_DIM);
68  }
69  }
70 }
71 
72 
74 RookPawnY::setUp(const Weights &weights)
75 {
76  for (int i = 0; i < ONE_DIM; ++i)
77  {
78  for (int s=0; s<NStages; ++s)
79  table[i][s] = weights.value(i + ONE_DIM*s);
80  }
81 }
82 
84 RookPawnY::eval(const NumEffectState &state,
85  const CArray2d<int, 2, 9> &pawns)
86 {
87  MultiInt result;
88  const CArray<Square,2> kings = {
89  state.kingSquare<BLACK>(),
90  state.kingSquare<WHITE>(),
91  };
92  for (int i = PtypeTraits<ROOK>::indexMin;
93  i < PtypeTraits<ROOK>::indexLimit;
94  ++i)
95  {
96  const Piece piece = state.pieceOf(i);
97  if (piece.isOnBoard())
98  {
99  if (piece.owner() == BLACK)
100  {
101  const int pawn_y =
102  pawns[BLACK][piece.square().x() - 1];
103  result +=
104  table[index(piece, pawn_y)] +
105  y_attack_table[indexY(kings[WHITE], piece, pawn_y)] +
106  y_defense_table[indexY(kings[BLACK], piece, pawn_y)];
107  }
108  else
109  {
110  int y = pawns[WHITE][piece.square().x() - 1];
111  if (y != 0)
112  y = 10 - y;
113  result -=
114  table[index(piece, y)] +
115  y_attack_table[indexY(kings[BLACK], piece, y)] +
116  y_defense_table[indexY(kings[WHITE], piece, y)];
117  }
118  }
119  }
120  return result;
121 }
122 
123 
125 
127 AllMajor::setUp(const Weights &weights,int stage)
128 {
129  weight[stage] = weights.value(0);
130 }
131 
132 
133 template <bool Opening>
135 
136 template <bool Opening>
137 void osl::eval::ml::
139 {
140  for (size_t i = 0; i < weights.dimension(); ++i)
141  {
142  table[i] = weights.value(i);
143  }
144 }
145 
146 template <bool Opening>
147 int osl::eval::ml::
149  const NumEffectState &state, Piece piece)
150 {
151  return piece.ptype() + (state.turn() == piece.owner() ? 0 : PTYPE_SIZE);
152 }
153 
154 template <bool Opening>
155 template <osl::Ptype PTYPE>
156 int osl::eval::ml::
158 {
159  int result = 0;
160  for (int i = PtypeTraits<PTYPE>::indexMin;
161  i < PtypeTraits<PTYPE>::indexLimit;
162  ++i)
163  {
164  const Piece piece = state.pieceOf(i);
165  if (piece.isOnBoard() &&
166  state.hasEffectAt(alt(piece.owner()), piece.square()))
167  {
168  const int weight = table[index(state, piece)];
169  if (piece.owner() == BLACK)
170  result += weight;
171  else
172  result -= weight;
173  }
174  }
175  return result;
176 }
177 
178 template <bool Opening>
179 int osl::eval::ml::
181 {
182  int result = 0;
183  result += evalOne<ROOK>(state);
184  result += evalOne<BISHOP>(state);
185  result += evalOne<GOLD>(state);
186  result += evalOne<SILVER>(state);
187 
188  return result;
189 }
190 
194 
205 
206 
207 template<osl::Player P>
208 inline
210  const NumEffectState& state,
211  Square rook,
212  Square myKing,
213  Square opKing,
214  Square up,
215  Square dp,
216  Square rp,
217  Square lp,
218  bool isP)
219 {
220  MultiInt result;
221  PtypeO uPtypeO=state.pieceAt(up).ptypeO();
222  PtypeO dPtypeO=state.pieceAt(dp).ptypeO();
223  PtypeO rPtypeO=state.pieceAt(rp).ptypeO();
224  PtypeO lPtypeO=state.pieceAt(lp).ptypeO();
225  if(P==WHITE){
226  uPtypeO=(PtypeO)(static_cast<int>(uPtypeO)^(~15));
227  dPtypeO=(PtypeO)(static_cast<int>(dPtypeO)^(~15));
228  rPtypeO=(PtypeO)(static_cast<int>(rPtypeO)^(~15));
229  lPtypeO=(PtypeO)(static_cast<int>(lPtypeO)^(~15));
230  up=up.rotate180EdgeOK();
231  dp=dp.rotate180EdgeOK();
232  rp=rp.rotate180EdgeOK();
233  lp=lp.rotate180EdgeOK();
234  rook=rook.rotate180();
235  myKing=myKing.rotate180();
236  opKing=opKing.rotate180();
237  }
238  assert((myKing.y()-dp.y())<(myKing.y()-up.y()));
239  assert((myKing.x()-lp.x())<(myKing.x()-rp.x()));
240  result+=attack_u[index1(opKing,up,uPtypeO,isP)]+
241  attack_d[index1(opKing,dp,dPtypeO,isP)]+
242  attack_l[index1(opKing,lp,lPtypeO,isP)]+
243  attack_r[index1(opKing,rp,rPtypeO,isP)]+
244  defense_u[index1(myKing,up,uPtypeO,isP)]+
245  defense_d[index1(myKing,dp,dPtypeO,isP)]+
246  defense_l[index1(myKing,lp,lPtypeO,isP)]+
247  defense_r[index1(myKing,rp,rPtypeO,isP)]+
248  attack_nospace[index2(opKing,rook,isP)]+
249  defense_nospace[index2(myKing,rook,isP)];
250  return result;
251 }
252 
255 {
256  const CArray<Square,2> kings = {
257  state.kingSquare(BLACK),
258  state.kingSquare(WHITE),
259  };
260  MultiInt result;
261  for (int i = PtypeTraits<ROOK>::indexMin; i < PtypeTraits<ROOK>::indexLimit;
262  ++i)
263  {
264  const Piece p = state.pieceOf(i);
265  if (! p.isOnBoard()) continue;
266  const Square pos=p.square();
267  Square up=state.mobilityOf(U,i);
268  Square dp=state.mobilityOf(D,i);
269  Square lp=state.mobilityOf(L,i);
270  Square rp=state.mobilityOf(R,i);
271  const bool isP=p.isPromoted();
272  if(p.owner()==BLACK)
273  result+=evalOne<BLACK>(state,pos,kings[0],kings[1],up,dp,rp,lp,isP);
274  else
275  result-=evalOne<WHITE>(state,pos,kings[1],kings[0],dp,up,lp,rp,isP);
276  }
277  return result;
278 }
279 
280 void osl::eval::ml::RookEffect::setUp(const Weights &weights,int stage)
281 {
282  for (size_t i = 0; i < ONE_DIM; ++i)
283  {
284  attack_table[i][stage] = weights.value(i);
285  defense_table[i][stage] = weights.value(i + ONE_DIM);
286  }
287 }
288 
290 {
291  for (size_t i = 0; i < 32; ++i)
292  {
293  for (int s=0; s<NStages; ++s)
294  RookEffectBase::piece_table[i][s] = weights.value(i + 32*s);
295  }
296 }
297 
300 {
301  CArray<MultiInt, 19584> piece_attack_table;
302  CArray<MultiInt, 19584> piece_defense_table;
303  for (size_t i = 0; i < ONE_DIM; ++i)
304  {
305  for (int s=0; s<NStages; ++s)
306  {
307  piece_attack_table[i][s] = weights.value(i + ONE_DIM*2*s);
308  piece_defense_table[i][s] = weights.value(i + ONE_DIM*2*s + ONE_DIM);
309  }
310  }
311  for(int isP=0;isP<2;isP++)
312  for(int y_diff=-9;y_diff<=9;y_diff++)
313  for(int x_diff= -9;x_diff<=9;x_diff++){
314  int i2=index2(x_diff,y_diff,isP);
315  if(abs(x_diff)<9 && abs(y_diff)<9){
316  attack_nospace[i2]=
317  -(attack_table[index(abs(x_diff),y_diff,true,isP)]+
318  attack_table[index(abs(x_diff),y_diff,false,isP)]);
319  defense_nospace[i2]=
320  -(defense_table[index(abs(x_diff),y_diff,true,isP)]+
321  defense_table[index(abs(x_diff),y_diff,false,isP)]);
322  }
323  for(int ptypeo= PTYPEO_MIN;ptypeo<=PTYPEO_MAX;ptypeo++){
324  if(getPtype((PtypeO)ptypeo)==(int)PTYPE_EMPTY) continue;
325  int i1=index1(x_diff,y_diff,(PtypeO)ptypeo,isP);
326  int indexPieceH,indexPieceV;
327  int table_ptypeo=ptypeo;
328  if(getPtype((PtypeO)ptypeo)==PTYPE_EDGE) table_ptypeo=PTYPEO_EDGE;
329  if(getPtype((PtypeO)ptypeo)==PTYPE_EDGE || abs(x_diff)==9 || abs(y_diff)==9){
330  indexPieceH= 0+0+(PTYPEO_EDGE-PTYPEO_MIN)*17*9+4896+isP*9792;
331  indexPieceV= 0+0+(PTYPEO_EDGE-PTYPEO_MIN)*17*9+ isP*9792;
332  }
333  else{
334  indexPieceH= index0(abs(x_diff),-y_diff,(PtypeO)ptypeo,true,isP);
335  indexPieceV= index0(abs(x_diff),-y_diff,(PtypeO)ptypeo,false,isP);
336  }
337  attack_u[i1]=piece_attack_table[indexPieceV]+piece_table[table_ptypeo-PTYPEO_MIN];
338  defense_u[i1]=piece_defense_table[indexPieceV];
339  attack_d[i1]=piece_attack_table[indexPieceV]+piece_table[table_ptypeo-PTYPEO_MIN];
340  defense_d[i1]=piece_defense_table[indexPieceV];
341  if(abs(x_diff)<=8){
342  for(int y_diff_1=y_diff+1;y_diff_1<=8;y_diff_1++){
343  int i=index(abs(x_diff),y_diff_1,false,isP);
344  attack_u[i1]+=attack_table[i];
345  defense_u[i1]+=defense_table[i];
346  }
347  for(int y_diff_1=std::max(-8,y_diff);y_diff_1<=8;y_diff_1++){
348  int i=index(abs(x_diff),y_diff_1,false,isP);
349  attack_d[i1]-=attack_table[i];
350  defense_d[i1]-=defense_table[i];
351  }
352  }
353  attack_l[i1]=piece_attack_table[indexPieceH]+piece_table[table_ptypeo-PTYPEO_MIN];
354  defense_l[i1]=piece_defense_table[indexPieceH];
355  attack_r[i1]=piece_attack_table[indexPieceH]+piece_table[table_ptypeo-PTYPEO_MIN];
356  defense_r[i1]=piece_defense_table[indexPieceH];
357  if(abs(y_diff)<=8){
358  for(int x_diff_1=x_diff+1;x_diff_1<=8;x_diff_1++){
359  int i=index(abs(x_diff_1),y_diff,true,isP);
360  attack_r[i1]+=attack_table[i];
361  defense_r[i1]+=defense_table[i];
362  }
363  for(int x_diff_1=std::max(-8,x_diff);x_diff_1<=8;x_diff_1++){
364  int i=index(abs(x_diff_1),y_diff,true,isP);
365  attack_l[i1]-=attack_table[i];
366  defense_l[i1]-=defense_table[i];
367  }
368  }
369  }
370  }
371 }
372 
373 
374 
377 
379 {
380  for (size_t i = 0; i < ONE_DIM; ++i)
381  {
382  for (int s=0; s<NStages; ++s)
383  promote_defense_table[i][s] = weights.value(i + ONE_DIM*s);
384  }
385 }
386 
388 {
389  for (size_t i = 0; i < ONE_DIM; ++i)
390  {
391  for (int s=0; s<NStages; ++s)
393  weights.value(i + ONE_DIM*s);
394  }
395 }
396 
399 {
400  MultiInt result;
401  for (int i = PtypeTraits<ROOK>::indexMin;
402  i < PtypeTraits<ROOK>::indexLimit;
403  ++i){
404  const Piece rook = state.pieceOf(i);
405  if(rook.isOnBoardNotPromoted()){
406  if(rook.owner()==BLACK){
407  Square rookPos=rook.square();
408  if(rookPos.y()>=4){
409  Square pos=state.mobilityOf(U,i);
410  const Piece attacked = state.pieceAt(pos);
411  if (attacked.canMoveOn<BLACK>()){
412  const NumBitmapEffect effect = state.effectSetAt(pos);
413  if (effect.countEffect(WHITE) == 1){
414  PieceMask mask = effect & state.piecesOnBoard(WHITE);
415  const Piece effect_piece = state.pieceOf(mask.takeOneBit());
416  const int index = attacked.ptype() * 16 + effect_piece.ptype();
417  result += promote_defense_table[index];
418  if (effect_piece.ptype() == ROOK &&
419  effect_piece.square().x() != rookPos.x())
420  {
421  result +=
422  promote_defense_rook_table[
423  attacked.ptype() * 9 +
424  mobility::RookMobility::countHorizontalAll<BLACK>(state,
425  rook)];
426  }
427  }
428  }
429  }
430  }
431  else{
432  Square rookPos=rook.square();
433  if(rookPos.y()<=6){
434  Square pos=state.mobilityOf(D,i);
435  const Piece attacked = state.pieceAt(pos);
436  if (attacked.canMoveOn<WHITE>()){
437  const NumBitmapEffect effect = state.effectSetAt(pos);
438  if (effect.countEffect(BLACK) == 1){
439  PieceMask mask = effect & state.piecesOnBoard(BLACK);
440  const Piece effect_piece = state.pieceOf(mask.takeOneBit());
441  const int index = attacked.ptype() * 16 + effect_piece.ptype();
442  result -= promote_defense_table[index];
443  if (effect_piece.ptype() == ROOK &&
444  effect_piece.square().x() != rookPos.x())
445  {
446  result -=
447  promote_defense_rook_table[
448  attacked.ptype() * 9 +
449  mobility::RookMobility::countHorizontalAll<WHITE>(state,
450  rook)];
451  }
452  }
453  }
454  }
455  }
456  }
457  }
458  return result;
459 }
460 
461 
462 
476 
477 
478 template<osl::Player P>
479 inline
481  const NumEffectState& state,
482  Square bishop,
483  Square myKing,
484  Square opKing,
485  Square ulp,
486  Square urp,
487  Square dlp,
488  Square drp,
489  bool isP)
490 {
491  MultiInt result;
492  PtypeO ulPtypeO=state.pieceAt(ulp).ptypeO();
493  PtypeO urPtypeO=state.pieceAt(urp).ptypeO();
494  PtypeO dlPtypeO=state.pieceAt(dlp).ptypeO();
495  PtypeO drPtypeO=state.pieceAt(drp).ptypeO();
496  if(P==WHITE){
497  ulPtypeO=(PtypeO)(static_cast<int>(ulPtypeO)^(~15));
498  urPtypeO=(PtypeO)(static_cast<int>(urPtypeO)^(~15));
499  dlPtypeO=(PtypeO)(static_cast<int>(dlPtypeO)^(~15));
500  drPtypeO=(PtypeO)(static_cast<int>(drPtypeO)^(~15));
501  ulp=ulp.rotate180EdgeOK();
502  urp=urp.rotate180EdgeOK();
503  dlp=dlp.rotate180EdgeOK();
504  drp=drp.rotate180EdgeOK();
505  bishop=bishop.rotate180();
506  myKing=myKing.rotate180();
507  opKing=opKing.rotate180();
508  }
509  result+=attack_ul[index1(opKing,ulp,ulPtypeO,isP)]+
510  attack_ur[index1(opKing,urp,urPtypeO,isP)]+
511  attack_dl[index1(opKing,dlp,dlPtypeO,isP)]+
512  attack_dr[index1(opKing,drp,drPtypeO,isP)]+
513  defense_ul[index1(myKing,ulp,ulPtypeO,isP)]+
514  defense_ur[index1(myKing,urp,urPtypeO,isP)]+
515  defense_dl[index1(myKing,dlp,dlPtypeO,isP)]+
516  defense_dr[index1(myKing,drp,drPtypeO,isP)]+
517  attack_nospace[index2(opKing,bishop,isP)]+
518  defense_nospace[index2(myKing,bishop,isP)];
519  return result;
520 }
521 
524 {
525  const CArray<Square,2> kings = {{
526  state.kingSquare(BLACK),
527  state.kingSquare(WHITE),
528  }};
529 
530  MultiInt result;
531  for (int i = PtypeTraits<BISHOP>::indexMin; i < PtypeTraits<BISHOP>::indexLimit;
532  ++i)
533  {
534  const Piece p = state.pieceOf(i);
535  if (! p.isOnBoard()) continue;
536  const Square pos=p.square();
537  Square ulp=state.mobilityOf(UL,i);
538  Square urp=state.mobilityOf(UR,i);
539  Square dlp=state.mobilityOf(DL,i);
540  Square drp=state.mobilityOf(DR,i);
541  const bool isP=p.isPromoted();
542  if(p.owner()==BLACK)
543  result+=evalOne<BLACK>(state,pos,kings[0],kings[1],ulp,urp,dlp,drp,isP);
544  else
545  result-=evalOne<WHITE>(state,pos,kings[1],kings[0],drp,dlp,urp,ulp,isP);
546  }
547  return result;
548 }
549 
550 void osl::eval::ml::BishopEffect::setUp(const Weights &weights,int stage)
551 {
552  for (size_t i = 0; i < ONE_DIM; ++i)
553  {
554  attack_table[i][stage] = weights.value(i);
555  defense_table[i][stage] = weights.value(i + ONE_DIM);
556  }
557 }
558 
560 {
561  for (size_t i = 0; i < 32; ++i)
562  {
563  for (int s=0; s<NStages; ++s)
564  BishopEffectBase::piece_table[i][s] = weights.value(i + 32*s);
565  }
566 }
567 
568 
571 {
572  CArray<MultiInt, 19584> piece_attack_table;
573  CArray<MultiInt, 19584> piece_defense_table;
574  for (size_t i = 0; i < ONE_DIM; ++i)
575  {
576  for (int s=0; s<NStages; ++s)
577  {
578  piece_attack_table[i][s] = weights.value(i + ONE_DIM * 2 * s);
579  piece_defense_table[i][s] = weights.value(i + ONE_DIM * 2 * s + ONE_DIM);
580  }
581  }
582  for(int isP=0;isP<2;isP++)
583  for(int y_diff=-9;y_diff<=9;y_diff++)
584  for(int x_diff= -9;x_diff<=9;x_diff++){
585  int i2=index2(x_diff,y_diff,isP);
586  if(abs(x_diff)<9 && abs(y_diff)<9){
587  attack_nospace[i2]=
588  -(attack_table[index(x_diff,y_diff,true,isP)]+
589  attack_table[index(x_diff,y_diff,false,isP)]);
590  defense_nospace[i2]=
591  -(defense_table[index(x_diff,y_diff,true,isP)]+
592  defense_table[index(x_diff,y_diff,false,isP)]);
593  }
594  for(int ptypeo= PTYPEO_MIN;ptypeo<=PTYPEO_MAX;ptypeo++){
595  if(getPtype((PtypeO)ptypeo)==(int)PTYPE_EMPTY) continue;
596  int i1=index1(x_diff,y_diff,(PtypeO)ptypeo,isP);
597  int indexPieceUR,indexPieceUL;
598  int table_ptypeo=ptypeo;
599  if(getPtype((PtypeO)ptypeo)==PTYPE_EDGE) table_ptypeo=PTYPEO_EDGE;
600  if(getPtype((PtypeO)ptypeo)==PTYPE_EDGE || abs(x_diff)==9 || abs(y_diff)==9){
601  indexPieceUR= 0+0+(PTYPEO_EDGE-PTYPEO_MIN)*17*9+4896+isP*9792;
602  indexPieceUL= 0+0+(PTYPEO_EDGE-PTYPEO_MIN)*17*9+ isP*9792;
603  }
604  else{
605  indexPieceUR= index0(x_diff,y_diff,(PtypeO)ptypeo,true,isP);
606  indexPieceUL= index0(x_diff,y_diff,(PtypeO)ptypeo,false,isP);
607  }
608  attack_ul[i1]=piece_attack_table[indexPieceUL]+piece_table[table_ptypeo-PTYPEO_MIN];
609  defense_ul[i1]=piece_defense_table[indexPieceUL];
610  attack_dr[i1]=piece_attack_table[indexPieceUL]+piece_table[table_ptypeo-PTYPEO_MIN];
611  defense_dr[i1]=piece_defense_table[indexPieceUL];
612  {
613  int y_diff_1=y_diff+1, x_diff_1=x_diff-1;
614  for(;y_diff_1<=8 && x_diff_1>=-8;y_diff_1++,x_diff_1--){
615  if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
616  int i=index(x_diff_1,y_diff_1,false,isP);
617  attack_ul[i1]+=attack_table[i];
618  defense_ul[i1]+=defense_table[i];
619  }
620  }
621  }
622  {
623  int y_diff_1=y_diff, x_diff_1=x_diff;
624  for(;y_diff_1<=8 && x_diff_1>=-8;y_diff_1++,x_diff_1--){
625  if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
626  int i=index(x_diff_1,y_diff_1,false,isP);
627  attack_dr[i1]-=attack_table[i];
628  defense_dr[i1]-=defense_table[i];
629  }
630  }
631  }
632  attack_ur[i1]=piece_attack_table[indexPieceUR]+piece_table[table_ptypeo-PTYPEO_MIN];
633  defense_ur[i1]=piece_defense_table[indexPieceUR];
634  attack_dl[i1]=piece_attack_table[indexPieceUR]+piece_table[table_ptypeo-PTYPEO_MIN];
635  defense_dl[i1]=piece_defense_table[indexPieceUR];
636  {
637  int y_diff_1=y_diff+1, x_diff_1=x_diff+1;
638  for(;y_diff_1<=8 && x_diff_1<=8;y_diff_1++,x_diff_1++){
639  if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
640  int i=index(x_diff_1,y_diff_1,true,isP);
641  attack_ur[i1]+=attack_table[i];
642  defense_ur[i1]+=defense_table[i];
643  }
644  }
645  }
646  {
647  int y_diff_1=y_diff, x_diff_1=x_diff;
648  for(;y_diff_1<=8 && x_diff_1<=8;y_diff_1++,x_diff_1++){
649  if(std::abs(x_diff_1)<=8 && std::abs(y_diff_1)<=8){
650  int i=index(x_diff_1,y_diff_1,true,isP);
651  attack_dl[i1]-=attack_table[i];
652  defense_dl[i1]-=defense_table[i];
653  }
654  }
655  }
656  }
657  }
658 }
659 
663 
665 {
666  for (size_t i = 0; i < ONE_DIM; ++i)
667  {
668  for (int s=0; s<NStages; ++s)
669  table[i][s] = weights.value(i + ONE_DIM*s);
670  }
671 }
672 
675 {
676  for (size_t i = 0; i < ONE_DIM; ++i)
677  {
678  for (int s=0; s<NStages; ++s)
679  BishopHead::king_table[i][s] = weights.value(i + ONE_DIM*s);
680  }
681  for(int x_diff=0;x_diff<=8;x_diff++)
682  for(int y_diff=-8;y_diff<=8;y_diff++){
683  for(int i=0;i<32;i++)
684  BishopHead::king_table[(i*9+x_diff)*17+y_diff+8]+=BishopHead::table[i];
685  }
686  const PtypeO PTYPEO_EMPTY_R=newPtypeO(WHITE,PTYPE_EMPTY);
687  const PtypeO PTYPEO_EDGE_R=newPtypeO(BLACK,PTYPE_EDGE);
688  for(int x_diff=0;x_diff<=8;x_diff++)
689  for(int y_diff=-8;y_diff<=8;y_diff++){
690  BishopHead::king_table[(ptypeOIndex(PTYPEO_EMPTY_R)*9+x_diff)*17+y_diff+8]=
691  BishopHead::king_table[(ptypeOIndex(PTYPEO_EMPTY)*9+x_diff)*17+y_diff+8];
692  BishopHead::king_table[(ptypeOIndex(PTYPEO_EDGE_R)*9+x_diff)*17+y_diff+8]=
693  BishopHead::king_table[(ptypeOIndex(PTYPEO_EDGE)*9+x_diff)*17+y_diff+8];
694  }
695 }
696 
698 {
699  for (size_t i = 0; i < ONE_DIM; ++i)
700  {
701  for (int s=0; s<NStages; ++s)
702  BishopHead::x_table[i][s] = weights.value(i + ONE_DIM*s);
703  }
704 }
705 
707 BishopHead::eval(const NumEffectState &state)
708 {
709  MultiInt result;
710  for (int i = PtypeTraits<BISHOP>::indexMin;
711  i < PtypeTraits<BISHOP>::indexLimit;
712  ++i){
713  const Piece p = state.pieceOf(i);
714  if (p.isOnBoardNotPromoted()){
715  const Square pos=p.square();
716  if (p.owner() == BLACK){
717  if(pos.y()>=2){
719  if (!state.hasEffectAt(BLACK, up)){
720  const Square king = state.kingSquare(BLACK);
721  const PtypeO ptypeo = state.pieceAt(up).ptypeO();
722  const int index_k = indexK(BLACK, ptypeo,
723  std::abs(pos.x() - king.x()),
724  pos.y() - king.y());
725  result += king_table[index_k];
726  result += x_table[indexX<BLACK>(ptypeo, pos.x())];
727  }
728  }
729  }
730  else if(pos.y()<=8) {
732  if (!state.hasEffectAt(WHITE, up)){
733  const Square king = state.kingSquare(WHITE);
734  const PtypeO ptypeo = state.pieceAt(up).ptypeO();
735  const int index_k = indexK(WHITE, ptypeo,
736  std::abs(pos.x() - king.x()),
737  pos.y() - king.y());
738  result -= king_table[index_k];
739  result -= x_table[indexX<WHITE>(ptypeo, pos.x())];
740  }
741  }
742  }
743  }
744  return result;
745 }
746 
747 
749 
751 {
752  for (size_t i = 0; i < ONE_DIM; ++i)
753  {
754  for (int s=0; s<NStages; ++s)
755  table[i][s] = weights.value(i + ONE_DIM*s);
756  }
757 }
758 
759 template<osl::Player P>
762 {
763  const Square king=state.kingSquare(P);
764  MultiInt result;
765  for (int i = PtypeTraits<ROOK>::indexMin;
766  i < PtypeTraits<ROOK>::indexLimit;
767  ++i)
768  {
769  const Piece rook = state.pieceOf(i);
770  if (!rook.isOnBoard())
771  {
772  continue;
773  }
774  for (int j = PtypeTraits<BISHOP>::indexMin;
775  j < PtypeTraits<BISHOP>::indexLimit;
776  ++j)
777  {
778  const Piece bishop = state.pieceOf(j);
779  if (!bishop.isOnBoard())
780  {
781  continue;
782  }
783  result += table[index<P>(king, rook, bishop)];
784  }
785  }
786  return result;
787 }
788 
791 {
792  return evalOne<BLACK>(state)-evalOne<WHITE>(state);
793 }
794 
795 
799 
802 {
803  for (size_t i = 0; i < ONE_DIM; ++i)
804  {
805  for (int s=0; s<NStages; ++s)
807  weights.value(i + ONE_DIM*s);
808  }
809 }
810 
813 {
814  for (size_t i = 0; i < ONE_DIM; ++i)
815  {
816  for (int s=0; s<NStages; ++s)
818  weights.value(i + ONE_DIM*s);
819  }
820 }
821 
824 {
825  for (size_t i = 0; i < ONE_DIM; ++i)
826  {
827  for (int s=0; s<NStages; ++s)
829  weights.value(i + ONE_DIM*s);
830  }
831 }
832 
835 {
836  MultiInt result;
837  for (int i = PtypeTraits<BISHOP>::indexMin;
838  i < PtypeTraits<BISHOP>::indexLimit;
839  ++i)
840  {
841  const Piece bishop = state.pieceOf(i);
842  if (!bishop.isOnBoard())
843  {
844  continue;
845  }
846  int self, opp, all;
847  countBetween(state,
848  state.kingSquare(alt(bishop.owner())),
849  bishop, self, opp, all);
850  if (bishop.owner() == BLACK)
851  {
852  result += (self_table[self] + opp_table[opp] + all_table[all]);
853  }
854  else
855  {
856  result -= (self_table[self] + opp_table[opp] + all_table[all]);
857  }
858  }
859  return result;
860 }
861 
864  const NumEffectState &state, Square king, Piece bishop,
865  int &self_count, int &opp_count, int &total_count)
866 {
867  assert(bishop.isOnBoard());
868  if ((king.x() + king.y() != bishop.square().x() + bishop.square().y()) &&
869  (king.x() - king.y() != bishop.square().x() - bishop.square().y()))
870  {
871  self_count = opp_count = total_count = 8;
872  return;
873  }
874  Direction dir;
875  assert(king.x() != bishop.square().x());
876  assert(king.y() != bishop.square().y());
877  if (king.x() < bishop.square().x())
878  {
879  if (king.y() < bishop.square().y())
880  {
881  dir = UR;
882  }
883  else
884  {
885  dir = DR;
886  }
887  }
888  else
889  {
890  if (king.y() < bishop.square().y())
891  {
892  dir = UL;
893  }
894  else
895  {
896  dir = DL;
897  }
898  }
899  const Player player = bishop.owner();
900  const Direction move_dir = (player == BLACK ? dir : inverse(dir));
901  self_count = opp_count = total_count = 0;
902  for (Square pos = state.mobilityOf(dir, bishop.number());
903  pos != king; pos = Board_Table.nextSquare(player, pos, move_dir))
904  {
905  assert(pos.isOnBoard());
906  const Piece piece = state.pieceAt(pos);
907  if (!piece.isEmpty())
908  {
909  ++total_count;
910  if (piece.owner() == player)
911  ++self_count;
912  else
913  ++opp_count;
914  }
915  }
916 }
917 
918 
921 
923 BishopBishopPiece::setUp(const Weights &weights)
924 {
925  for (size_t i = 0; i < ONE_DIM; ++i)
926  {
927  for (int s=0; s<NStages; ++s)
928  table[i][s] = weights.value(i + ONE_DIM*s);
929  }
930 }
931 
934 {
935  MultiInt result;
936  const Piece bishop1 = state.pieceOf(PtypeTraits<BISHOP>::indexMin);
937  const Piece bishop2 = state.pieceOf(PtypeTraits<BISHOP>::indexMin + 1);
938  if (!bishop1.isOnBoard() || !bishop2.isOnBoard() ||
939  bishop1.owner() == bishop2.owner())
940  return result;
941  if (bishop1.square().x() + bishop1.square().y() !=
942  bishop2.square().x() + bishop2.square().y() &&
943  bishop1.square().x() - bishop1.square().y() !=
944  bishop2.square().x() - bishop2.square().y())
945  return result;
946 
947  if (state.hasEffectByPtype<BISHOP>(bishop2.owner(), bishop1.square()))
948  return result;
949 
950  Direction dir;
951  if (bishop1.square().x() < bishop2.square().x())
952  {
953  if (bishop1.square().y() < bishop2.square().y())
954  {
955  dir = UR;
956  }
957  else
958  {
959  dir = DR;
960  }
961  }
962  else
963  {
964  if (bishop1.square().y() < bishop2.square().y())
965  {
966  dir = UL;
967  }
968  else
969  {
970  dir = DL;
971  }
972  }
973  Square p1 = state.mobilityOf(inverse(dir), bishop1.number());
974  Square p2 = state.mobilityOf(dir, bishop2.number());
975  if (p1 == p2)
976  {
977  const Piece p = state.pieceAt(p1);
978  const bool black_with_support =
979  state.hasEffectAt<BLACK>(bishop1.owner() == BLACK ?
980  bishop1.square() : bishop2.square());
981  const bool white_with_support =
982  state.hasEffectAt<WHITE>(bishop1.owner() == WHITE ?
983  bishop1.square() : bishop2.square());
984  if (p.owner() == BLACK)
985  {
986  result += table[index(p.ptype(), black_with_support,
987  white_with_support)];
988  }
989  else
990  {
991  result -= table[index(p.ptype(), white_with_support,
992  black_with_support)];
993  }
994  }
995  return result;
996 }
997 
1000 
1002 RookRook::setUp(const Weights &weights)
1003 {
1004  CArray<MultiInt, 800> orig_table;
1005  for (size_t i = 0; i < ONE_DIM; ++i)
1006  {
1007  for (int s=0; s<NStages; ++s)
1008  orig_table[i][s] = weights.value(i + ONE_DIM*s);
1009  }
1010  for (int owner = 0; owner < 2; ++owner)
1011  {
1012  const bool same_player = (owner == 0);
1013  for (int y1 = 0; y1 < 10; ++y1)
1014  {
1015  for (int y2 = 0; y2 < 10; ++y2)
1016  {
1017  for (int promoted1 = 0; promoted1 < 2; ++promoted1)
1018  {
1019  for (int promoted2 = 0; promoted2 < 2; ++promoted2)
1020  {
1021  if (same_player)
1022  {
1023  int y1p = y1;
1024  int y2p = y2;
1025  int promoted1p = promoted1;
1026  int promoted2p = promoted2;
1027  if (y1 > y2 || (y1 == y2 && !promoted1 && promoted2))
1028  {
1029  std::swap(y1p, y2p);
1030  std::swap(promoted1p, promoted2p);
1031  }
1032  table[index(same_player, promoted1, promoted2,
1033  y1, y2)] =
1034  orig_table[index(same_player, promoted1p, promoted2p,
1035  y1p, y2p)];
1036  }
1037  else
1038  {
1039  if (y1 + y2 > 10 || y1 == 0 ||
1040  (y1 + y2 == 10 && promoted1))
1041  {
1042  const int idx = index(same_player, promoted1, promoted2,
1043  y1, y2);
1044  table[idx] = orig_table[idx];
1045  }
1046  else
1047  {
1048  table[index(same_player, promoted1, promoted2,
1049  y1, y2)] =
1050  -orig_table[index(same_player, promoted2, promoted1,
1051  (10 - y2) % 10, (10 - y1) % 10)];
1052  }
1053  }
1054  }
1055  }
1056  }
1057  }
1058  }
1059 }
1060 
1062 RookRook::eval(const NumEffectState &state)
1063 {
1064  MultiInt result;
1065  Piece rook1 = state.pieceOf(PtypeTraits<ROOK>::indexMin);
1066  Piece rook2 = state.pieceOf(PtypeTraits<ROOK>::indexMin + 1);
1067  if (rook1.owner() == rook2.owner())
1068  {
1069  if (rook1.owner() == BLACK)
1070  {
1071  result += table[index<true, BLACK>(rook1, rook2)];
1072  }
1073  else
1074  {
1075  result -= table[index<true, WHITE>(rook1, rook2)];
1076  }
1077  }
1078  else
1079  {
1080  if (rook1.owner() != BLACK)
1081  {
1082  std::swap(rook1, rook2);
1083  }
1084  result += table[index<false, BLACK>(rook1, rook2)];
1085  }
1086  return result;
1087 }
1088 
1089 
1092 
1094 RookRookPiece::setUp(const Weights &weights)
1095 {
1096  for (size_t i = 0; i < ONE_DIM; ++i)
1097  {
1098  for (int s=0; s<NStages; ++s)
1099  table[i][s] = weights.value(i + ONE_DIM*s);
1100  }
1101 }
1102 
1104 RookRookPiece::eval(const NumEffectState &state)
1105 {
1106  MultiInt result;
1107  const Piece rook1 = state.pieceOf(PtypeTraits<ROOK>::indexMin);
1108  const Piece rook2 = state.pieceOf(PtypeTraits<ROOK>::indexMin + 1);
1109  if (!rook1.isOnBoard() || !rook2.isOnBoard() ||
1110  rook1.owner() == rook2.owner())
1111  return result;
1112 
1113  if (state.hasEffectByPtype<ROOK>(rook2.owner(), rook1.square()))
1114  return result;
1115 
1116  Direction dir;
1117  bool vertical = false;
1118  if (rook1.square().x() == rook2.square().x())
1119  {
1120  vertical = true;
1121  if (rook1.square().y() < rook2.square().y())
1122  {
1123  dir = D;
1124  }
1125  else
1126  {
1127  dir = U;
1128  }
1129  }
1130  else if (rook1.square().y() == rook2.square().y())
1131  {
1132  if (rook1.square().x() < rook2.square().x())
1133  {
1134  dir = L;
1135  }
1136  else
1137  {
1138  dir = R;
1139  }
1140  }
1141  else
1142  {
1143  return result;
1144  }
1145 
1146  Square p1 = state.mobilityOf(dir, rook1.number());
1147  Square p2 = state.mobilityOf(inverse(dir), rook2.number());
1148  assert(p1.isOnBoard() && p2.isOnBoard());
1149  if (p1 == p2)
1150  {
1151  const Piece p = state.pieceAt(p1);
1152  const bool black_with_support =
1153  state.hasEffectAt<BLACK>(rook1.owner() == BLACK ?
1154  rook1.square() : rook2.square());
1155  const bool white_with_support =
1156  state.hasEffectAt<WHITE>(rook1.owner() == WHITE ?
1157  rook1.square() : rook2.square());
1158  if (p.owner() == BLACK)
1159  {
1160  result += table[index(p.ptype(), black_with_support,
1161  white_with_support, vertical)];
1162  }
1163  else
1164  {
1165  result -= table[index(p.ptype(), white_with_support,
1166  black_with_support, vertical)];
1167  }
1168  }
1169  return result;
1170 }
1171 
1172 
1175 
1177 BishopStandFile5::setUp(const Weights &weights)
1178 {
1179  for (size_t i = 0; i < ONE_DIM; ++i)
1180  {
1181  for (int s=0; s<NStages; ++s)
1182  table[i][s] = weights.value(i + ONE_DIM*s);
1183  }
1184 }
1185 
1188 {
1189  MultiInt result;
1190  if (state.hasPieceOnStand<BISHOP>(BLACK))
1191  {
1192  result += table[ptypeOIndex(state.pieceAt(Square(5, 3)).ptypeO())];
1193  }
1194  if (state.hasPieceOnStand<BISHOP>(WHITE))
1195  {
1196  PtypeO ptypeO = state.pieceAt(Square(5, 7)).ptypeO();
1197  ptypeO = altIfPiece(ptypeO);
1198  result -= table[ptypeOIndex(ptypeO)];
1199  }
1200  return result;
1201 }
1202 
1203 
1204 
1207 
1209 MajorCheckWithCapture::setUp(const Weights &weights)
1210 {
1211  for (size_t i = 0; i < ONE_DIM; ++i)
1212  {
1213  for (int s=0; s<NStages; ++s)
1214  table[i][s] = weights.value(i + ONE_DIM*s);
1215  }
1216 }
1217 
1218 template <osl::Player Owner>
1221 {
1222  const Square king = state.kingSquare(Owner);
1223  PieceMask pieces = state.effectedMask(alt(Owner));
1224  pieces &= state.piecesOnBoard(Owner);
1225  pieces &= ~state.effectedMask(Owner);
1226  MultiInt sum;
1227  while (pieces.any()) {
1228  const Piece p = state.pieceOf(pieces.takeOneBit());
1229  const Square sq = p.square();
1230  if (state.hasLongEffectAt<ROOK>(alt(Owner), sq)
1231  && state.hasEffectIf(newPtypeO(BLACK,ROOK), sq, king)) {
1232  if (Owner == BLACK)
1233  sum += table[index(p.ptype(), true, sq.canPromote(alt(Owner)))];
1234  else
1235  sum -= table[index(p.ptype(), true, sq.canPromote(alt(Owner)))];
1236  }
1237  if (state.hasLongEffectAt<BISHOP>(alt(Owner), sq)
1238  && state.hasEffectIf(newPtypeO(BLACK,BISHOP), sq, king)) {
1239  if (Owner == BLACK)
1240  sum += table[index(p.ptype(), false, sq.canPromote(alt(Owner)))];
1241  else
1242  sum -= table[index(p.ptype(), false, sq.canPromote(alt(Owner)))];
1243  }
1244  }
1245  return sum;
1246 }
1247 
1250 {
1251  return addOne<BLACK>(state) + addOne<WHITE>(state);
1252 }
1253 
1254 
1257 
1259 RookSilverKnight::setUp(const Weights &weights)
1260 {
1261  for (size_t i = 0; i < ONE_DIM; ++i)
1262  {
1263  for (int s=0; s<NStages; ++s)
1264  table[i][s] = weights.value(i + ONE_DIM*s);
1265  }
1266 }
1267 
1270 {
1271  MultiInt result;
1272  for (int i = PtypeTraits<ROOK>::indexMin;
1273  i < PtypeTraits<ROOK>::indexLimit;
1274  ++i)
1275  {
1276  const Piece rook = state.pieceOf(i);
1277  if (!rook.isOnBoard())
1278  {
1279  continue;
1280  }
1281  for (int i = PtypeTraits<SILVER>::indexMin;
1282  i < PtypeTraits<SILVER>::indexLimit;
1283  ++i)
1284  {
1285  const Piece silver = state.pieceOf(i);
1286  if (!silver.isOnBoard() || silver.isPromoted() ||
1287  silver.owner() != rook.owner())
1288  {
1289  continue;
1290  }
1291  for (int i = PtypeTraits<KNIGHT>::indexMin;
1292  i < PtypeTraits<KNIGHT>::indexLimit;
1293  ++i)
1294  {
1295  const Piece knight = state.pieceOf(i);
1296  if (!knight.isOnBoard() || knight.isPromoted() ||
1297  knight.owner() != rook.owner())
1298  {
1299  continue;
1300  }
1301 
1302  if (rook.owner() == BLACK)
1303  {
1304  if (rook.square().x() > 5)
1305  {
1306  result += table[index(9 - rook.square().x(), rook.square().y() - 1,
1307  9 - silver.square().x(), silver.square().y() - 1,
1308  9 - knight.square().x(), knight.square().y() - 1)];
1309  }
1310  else
1311  {
1312  result += table[index(rook.square().x() - 1, rook.square().y() - 1,
1313  silver.square().x() - 1, silver.square().y() - 1,
1314  knight.square().x() - 1, knight.square().y() - 1)];
1315  }
1316  }
1317  else
1318  {
1319  if (rook.square().x() >= 5)
1320  {
1321  result -= table[index(9 - rook.square().x(), 9 - rook.square().y(),
1322  9 - silver.square().x(), 9 - silver.square().y(),
1323  9 - knight.square().x(), 9 - knight.square().y())];
1324  }
1325  else
1326  {
1327  result -= table[index(rook.square().x() - 1, 9 - rook.square().y(),
1328  silver.square().x() - 1, 9 - silver.square().y(),
1329  knight.square().x() - 1, 9 - knight.square().y())];
1330  }
1331  }
1332  }
1333  }
1334  }
1335  return result;
1336 }
1337 
1338 
1341 
1343 BishopSilverKnight::setUp(const Weights &weights)
1344 {
1345  for (size_t i = 0; i < ONE_DIM; ++i)
1346  {
1347  for (int s=0; s<NStages; ++s)
1348  table[i][s] = weights.value(i + ONE_DIM*s);
1349  }
1350 }
1351 
1354 {
1355  MultiInt result;
1356  for (int i = PtypeTraits<BISHOP>::indexMin;
1357  i < PtypeTraits<BISHOP>::indexLimit;
1358  ++i)
1359  {
1360  const Piece bishop = state.pieceOf(i);
1361  if (!bishop.isOnBoard())
1362  {
1363  continue;
1364  }
1365  for (int i = PtypeTraits<SILVER>::indexMin;
1366  i < PtypeTraits<SILVER>::indexLimit;
1367  ++i)
1368  {
1369  const Piece silver = state.pieceOf(i);
1370  if (!silver.isOnBoard() || silver.isPromoted() ||
1371  silver.owner() != bishop.owner())
1372  {
1373  continue;
1374  }
1375  for (int i = PtypeTraits<KNIGHT>::indexMin;
1376  i < PtypeTraits<KNIGHT>::indexLimit;
1377  ++i)
1378  {
1379  const Piece knight = state.pieceOf(i);
1380  if (!knight.isOnBoard() || knight.isPromoted() ||
1381  knight.owner() != bishop.owner())
1382  {
1383  continue;
1384  }
1385 
1386  if (bishop.owner() == BLACK)
1387  {
1388  if (bishop.square().x() > 5)
1389  {
1390  result += table[index(9 - bishop.square().x(), bishop.square().y() - 1,
1391  9 - silver.square().x(), silver.square().y() - 1,
1392  9 - knight.square().x(), knight.square().y() - 1)];
1393  }
1394  else
1395  {
1396  result += table[index(bishop.square().x() - 1, bishop.square().y() - 1,
1397  silver.square().x() - 1, silver.square().y() - 1,
1398  knight.square().x() - 1, knight.square().y() - 1)];
1399  }
1400  }
1401  else
1402  {
1403  if (bishop.square().x() >= 5)
1404  {
1405  result -= table[index(9 - bishop.square().x(), 9 - bishop.square().y(),
1406  9 - silver.square().x(), 9 - silver.square().y(),
1407  9 - knight.square().x(), 9 - knight.square().y())];
1408  }
1409  else
1410  {
1411  result -= table[index(bishop.square().x() - 1, 9 - bishop.square().y(),
1412  silver.square().x() - 1, 9 - silver.square().y(),
1413  knight.square().x() - 1, 9 - knight.square().y())];
1414  }
1415  }
1416  }
1417  }
1418  }
1419  return result;
1420 }
1421 
1422 
1425 
1427 AttackMajorsInBase::setUp(const Weights &weights)
1428 {
1429  for (size_t i = 0; i < ONE_DIM; ++i) {
1430  for (int s=0; s<NStages; ++s)
1431  table[i][s] = weights.value(i + ONE_DIM*s);
1432  if (i > 0)
1433  table[i] += table[0];
1434  }
1435 }
1436 
1437 template <osl::Player P>
1439 AttackMajorsInBase::addOne(const NumEffectState &state, Piece rook, MultiInt& result)
1440 {
1441  Square sq = rook.square();
1442  if (state.hasEffectAt(alt(P), sq)
1443  || sq.squareForBlack(P).y() < 8)
1444  return;
1445  typedef std::pair<Offset,Square> pair_t;
1446  const CArray<pair_t, 7> bishop_attack =
1447  {{
1448  pair_t(Offset::make<P,U>(), sq.neighbor<P, UL>()),
1449  pair_t(Offset::make<P,U>(), sq.neighbor<P, UR>()),
1450  pair_t(Offset::make<P,L>(), sq.neighbor<P, UL>()),
1451  pair_t(Offset::make<P,R>(), sq.neighbor<P, UR>()),
1452  pair_t(Offset::make<P,D>(), sq.neighbor<P, UL>()),
1453  pair_t(Offset::make<P,D>(), sq.neighbor<P, UR>()),
1454  pair_t(Offset::make<P,U>(), sq.neighbor<P, U>()),
1455  }};
1456  const bool has_gold = state.hasPieceOnStand(alt(P), GOLD);
1457  const bool rook_support = state.hasEffectAt(P, sq);
1458  for (pair_t pair: bishop_attack) {
1459  const Square attack_square = pair.second;
1460  if (! state[attack_square].isEmpty()
1461  || state.countEffect(P, attack_square) > 1)
1462  continue;
1463  const Square bishop_square = attack_square + pair.first;
1464  Piece p = state[bishop_square];
1465  if (! p.isPlayerPtype(P,BISHOP)
1466  || state.hasEffectAt(alt(P), bishop_square))
1467  continue;
1468  int a = state.countEffect(alt(P), attack_square) + has_gold;
1469  if (a <= state.countEffect(P, attack_square))
1470  continue;
1471  const int i = index(state.findCheapAttack(P, attack_square).ptype(),
1472  state.findCheapAttack(alt(P), attack_square).ptype(),
1473  has_gold, rook_support,
1474  state.hasEffectNotBy(P, rook, bishop_square));
1475  if (P == BLACK)
1476  result += table[i];
1477  else
1478  result -= table[i];
1479  }
1480 }
1481 
1484 {
1485  MultiInt result;
1486  for (int i=0; i<state.nthLimit<ROOK>(); ++i) {
1487  const Piece rook = state.nth<ROOK>(i);
1488  if (! rook.isOnBoard() || rook.isPromoted())
1489  continue;
1490  Player P = rook.owner();
1491  if (P == BLACK)
1492  addOne<BLACK>(state, rook, result);
1493  else
1494  addOne<WHITE>(state, rook, result);
1495  }
1496  return result;
1497 }
1498 
1499 
1500 namespace osl
1501 {
1502  namespace eval
1503  {
1504  namespace ml
1505  {
1506  template class MajorY<true, ROOK>;
1507  template class MajorY<false, ROOK>;
1508  template class MajorY<true, BISHOP>;
1509  template class MajorY<false, BISHOP>;
1510  template class RookPawn<true>;
1511  template class RookPawn<false>;
1512  template class MajorGoldSilverAttacked<false>;
1513  template MultiInt KingRookBishop::evalOne<BLACK>(const NumEffectState &state);
1514  template MultiInt KingRookBishop::evalOne<WHITE>(const NumEffectState &state);
1515  }
1516  }
1517 }
1518 
1519 // ;;; Local Variables:
1520 // ;;; mode:c++
1521 // ;;; c-basic-offset:2
1522 // ;;; End:
osl::eval::ml::BishopHead::king_table
static CArray< MultiInt, 4896 > king_table
Definition: majorPiece.h:461
osl::eval::ml::BishopStandFile5::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:1177
osl::Piece::number
int number() const
Definition: basic_type.h:828
osl::UR
@ UR
Definition: basic_type.h:315
osl::eval::ml::RookRookPiece::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1104
osl::SimpleState::pieceAt
const Piece pieceAt(Square sq) const
Definition: simpleState.h:167
osl::Square
Definition: basic_type.h:532
osl::eval::ml::RookEffectBase::attack_l
static CArray< MultiInt, 23104 > attack_l
Definition: majorPiece.h:258
osl::NumEffectState::piecesOnBoard
const PieceMask & piecesOnBoard(Player p) const
Definition: numEffectState.h:63
osl::eval::ml::MajorCheckWithCapture::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:1209
osl::NumEffectState::findCheapAttack
const Piece findCheapAttack(Player P, Square square) const
Definition: numEffectState.h:560
osl::eval::ml::RookPawn::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:26
osl::container::QuadInt
Definition: quadInt.h:43
osl::eval::ml::RookEffectBase::defense_r
static CArray< MultiInt, 23104 > defense_r
Definition: majorPiece.h:263
osl::eval::ml::RookEffect::setUp
static void setUp(const Weights &weights, int stage)
Definition: majorPiece.cc:280
osl::WHITE
@ WHITE
Definition: basic_type.h:10
osl::eval::ml::BishopStandFile5::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1187
osl::eval::ml::RookEffectBase::index2
static int index2(Square king, Square from, bool isP)
黒の飛車(竜)がある場所は空マスでないのでその分を補正するテーブル {attack,defense}_nospace へのアクセス king - 玉の位置 from - 飛車(竜)の位置 isP - 竜...
Definition: majorPiece.h:234
osl::eval::ml::RookPromoteDefense::promote_defense_table
static CArray< MultiInt, 256 > promote_defense_table
Definition: majorPiece.h:294
osl::Square::isOnBoard
bool isOnBoard() const
盤面上を表すかどうかの判定. 1<=x() && x()<=9 && 1<=y() && y()<=9 Squareの内部表現に依存する.
Definition: basic_type.h:583
osl::Piece::canMoveOn
bool canMoveOn() const
Player Pの駒が,thisの上に移動できるか? PIECE_EMPTY 0x00008000 BLACK_PIECE 0x000XxxYY X>=2, YY>0 PIECE_EDGE 0xfff1...
Definition: basic_type.h:980
osl::eval::ml::KingRookBishop::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:750
osl::Board_Table
const BoardTable Board_Table
Definition: tables.cc:95
osl::R
@ R
Definition: basic_type.h:317
osl::inverse
constexpr Direction inverse(Direction d)
Definition: basic_type.h:358
osl::alt
constexpr Player alt(Player player)
Definition: basic_type.h:13
osl::PTYPE_SIZE
const int PTYPE_SIZE
Definition: basic_type.h:107
osl::eval::ml::RookPawn
Definition: majorPiece.h:66
osl::eval::ml::BishopEffectBase::defense_table
static CArray< MultiInt, 612 > defense_table
Definition: majorPiece.h:394
osl::NumEffectState::effectSetAt
const NumBitmapEffect effectSetAt(Square sq) const
Definition: numEffectState.h:258
eval
rookMobility.h
osl::eval::ml::BishopEffectBase::evalOne
static MultiInt evalOne(const NumEffectState &state, Square bishop, Square myKing, Square opKing, Square ulp, Square urp, Square dlp, Square drp, bool isP)
Definition: majorPiece.cc:480
osl::eval::ml::BishopStandFile5::table
static CArray< MultiInt, 32 > table
Definition: majorPiece.h:630
osl::getPtype
Ptype getPtype(PtypeO ptypeO)
Definition: basic_type.h:217
osl::eval::ml::RookPromoteDefense::promote_defense_rook_table
static CArray< MultiInt, 144 > promote_defense_rook_table
Definition: majorPiece.h:295
osl::eval::ml::AllMajor::weight
static MultiInt weight
Definition: majorPiece.h:131
osl::eval::ml::RookEffectBase::attack_d
static CArray< MultiInt, 23104 > attack_d
Definition: majorPiece.h:257
osl::eval::ml::RookPawnY::y_defense_table
static CArray< MultiInt, 1620 > y_defense_table
Definition: majorPiece.h:106
osl::altIfPiece
PtypeO altIfPiece(PtypeO ptypeO)
Pieceの時にはowner を反転する
Definition: basic_type.h:281
osl::eval::ml::BishopEffectBase::defense_ul
static CArray< MultiInt, 23104 > defense_ul
Definition: majorPiece.h:401
osl::Piece::ptypeO
PtypeO ptypeO() const
Definition: basic_type.h:824
osl::eval::ml::NumPiecesBetweenBishopAndKing::opp_table
static CArray< MultiInt, 9 > opp_table
Definition: majorPiece.h:511
osl::eval::ml::Weights
Definition: weights.h:18
osl::PtypeTraits
Definition: ptypeTraits.h:12
osl::eval::ml::MajorGoldSilverAttacked::eval
static int eval(const NumEffectState &state)
Definition: majorPiece.cc:180
osl::eval::ml::MajorCheckWithCapture::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1249
osl::eval::ml::BishopEffectBase::attack_dl
static CArray< MultiInt, 23104 > attack_dl
Definition: majorPiece.h:399
osl::newPtypeO
PtypeO newPtypeO(Player player, Ptype ptype)
Definition: basic_type.h:211
osl::NumEffectState::effectedMask
const PieceMask effectedMask(Player pl) const
pl からの利きが(1つ以上)ある駒一覧
Definition: numEffectState.h:130
osl::eval::ml::AllMajor::setUp
static void setUp(const Weights &weights, int stage)
Definition: majorPiece.cc:127
osl::eval::ml::MajorGoldSilverAttacked::evalOne
static int evalOne(const NumEffectState &state)
Definition: majorPiece.cc:157
osl::eval::ml::NumPiecesBetweenBishopAndKing::self_table
static CArray< MultiInt, 9 > self_table
Definition: majorPiece.h:510
osl::PTYPEO_MAX
@ PTYPEO_MAX
Definition: basic_type.h:201
osl::NumEffectState::hasEffectIf
bool hasEffectIf(PtypeO ptypeo, Square attacker, Square target) const
attackerにptypeoの駒がいると仮定した場合にtargetに利きがあるかどうか を stateをupdateしないで確かめる.
Definition: numEffectState.h:465
osl::eval::ml::MajorGoldSilverAttacked::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:138
osl::eval::ml::Weights::value
int value(size_t index) const
Definition: weights.h:27
osl::eval::ml::RookEffectPieceKingRelative::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:299
osl::eval::ml::MajorCheckWithCapture::addOne
static MultiInt addOne(const NumEffectState &state)
osl::eval::ml::MajorCheckWithCapture::table
static CArray< MultiInt, ONE_DIM > table
Definition: majorPiece.h:643
osl::eval::ml::RookSilverKnight::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1269
osl::eval::ml::BishopHead::table
static CArray< MultiInt, 32 > table
Definition: majorPiece.h:460
osl::eval::ml::RookEffectBase::defense_d
static CArray< MultiInt, 23104 > defense_d
Definition: majorPiece.h:261
osl::NumEffectState::hasEffectAt
bool hasEffectAt(Square target) const
対象とするマスにあるプレイヤーの利きがあるかどうか.
Definition: numEffectState.h:324
osl::D
@ D
Definition: basic_type.h:319
osl::DirectionPlayerTraits
Definition: directionTraits.h:242
osl::SimpleState::nthLimit
static int nthLimit()
Definition: simpleState.h:105
osl::eval::ml::BishopSilverKnight::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1353
osl::eval::ml::NumPiecesBetweenBishopAndKing::countBetween
static void countBetween(const NumEffectState &state, Square king, Piece bishop, int &self_count, int &opp_count, int &total_count)
Definition: majorPiece.cc:863
osl::eval::ml::AttackMajorsInBase::table
static CArray< MultiInt, ONE_DIM > table
Definition: majorPiece.h:698
osl::Piece
駒.
Definition: basic_type.h:788
osl::eval::ml::RookRook::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1062
osl::eval::ml::RookEffectPiece::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:289
osl::GOLD
@ GOLD
Definition: basic_type.h:94
osl::eval::max
int max(Player p, int v1, int v2)
Definition: evalTraits.h:84
osl::eval::ml::BishopBishopPiece::table
static CArray< MultiInt, 64 > table
Definition: majorPiece.h:545
osl::SimpleState::pieceOf
const Piece pieceOf(int num) const
Definition: simpleState.h:76
osl::DR
@ DR
Definition: basic_type.h:320
osl::eval::ml::RookEffectBase::evalOne
static MultiInt evalOne(const NumEffectState &state, Square rook, Square myKing, Square opKing, Square up, Square dp, Square rp, Square lp, bool isP)
Definition: majorPiece.cc:209
osl::eval::ml::RookEffectBase::index1
static int index1(Square king, Square from, PtypeO ptypeO, bool isP)
黒の飛車(竜)からの利きのある駒のindex {attack,defense}_{u,r,l,d} へのアクセスに使う from - 駒の位置 king - 玉の位置 ptypeO - 駒の種類,白から...
Definition: majorPiece.h:205
osl::eval::ml::RookRook::table
static CArray< MultiInt, 800 > table
Definition: majorPiece.h:603
osl::eval::ml::RookPawnY::eval
static MultiInt eval(const NumEffectState &state, const CArray2d< int, 2, 9 > &pawns)
Definition: majorPiece.cc:84
osl::eval::ml::BishopEffectBase::piece_table
static CArray< MultiInt, 32 > piece_table
Definition: majorPiece.h:395
osl::eval::ml::RookPawnY::table
static CArray< MultiInt, 180 > table
Definition: majorPiece.h:104
osl::eval::ml::RookPromoteDefenseRookH::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:387
osl::eval::ml::RookRookPiece::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:1094
osl::eval::ml::BishopEffectBase::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:523
osl::eval::ml::BishopEffectPiece::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:559
osl::eval::ml::RookEffectBase::defense_table
static CArray< MultiInt, 612 > defense_table
Definition: majorPiece.h:254
osl::eval::ml::ppair::x_table
CArray< PiecePair::IndexTable, 10 > & x_table
Definition: piecePair.cc:35
osl::eval::ml::RookEffectBase::attack_table
static CArray< MultiInt, 612 > attack_table
Definition: majorPiece.h:253
osl::eval::ml::RookEffectBase::piece_table
static CArray< MultiInt, 32 > piece_table
Definition: majorPiece.h:255
osl::BISHOP
@ BISHOP
Definition: basic_type.h:99
osl::container::PieceMask64::takeOneBit
int takeOneBit()
Definition: pieceMask64.h:82
osl::NumEffectState::hasEffectNotBy
bool hasEffectNotBy(Player player, Piece piece, Square target) const
対象とするマスにあるプレイヤーの(ただしある駒以外)利きがあるかどうか.
Definition: numEffectState.h:409
osl::SimpleState::nth
const Piece nth(int n) const
unpromote(PTYPE)のn番目の駒を帰す.
Definition: simpleState.h:114
osl::eval::ml::BishopEffectBase::attack_dr
static CArray< MultiInt, 23104 > attack_dr
Definition: majorPiece.h:398
osl::eval::ml::RookRook::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:1002
osl::NumEffectState::hasLongEffectAt
bool hasLongEffectAt(Player P, Square to) const
あるマスにPTYPEの長い利きがあるかどうか.
Definition: numEffectState.h:346
osl::eval::ml::BishopBishopPiece::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:923
osl::L
@ L
Definition: basic_type.h:316
osl::eval::ml::RookEffectBase::attack_r
static CArray< MultiInt, 23104 > attack_r
Definition: majorPiece.h:259
osl::eval::ml::KingRookBishop::evalOne
static MultiInt evalOne(const NumEffectState &state)
Definition: majorPiece.cc:761
osl::eval::ml::NumPiecesBetweenBishopAndKing::all_table
static CArray< MultiInt, 9 > all_table
Definition: majorPiece.h:512
osl::Piece::isPromoted
bool isPromoted() const
promoteした駒かどうかをチェックする
Definition: basic_type.h:898
osl::eval::ml::BishopHead::x_table
static CArray< MultiInt, 160 > x_table
Definition: majorPiece.h:462
osl::eval::ml::RookSilverKnight::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:1259
osl::eval::ml::AttackMajorsInBase::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1483
osl::eval::ml::BishopBishopPiece::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:933
osl::Piece::owner
Player owner() const
Definition: basic_type.h:963
osl::SimpleState::hasPieceOnStand
bool hasPieceOnStand(Player player, Ptype ptype) const
Definition: simpleState.h:191
osl::Square::x
int x() const
将棋としてのX座標を返す.
Definition: basic_type.h:563
osl::eval::ml::BishopEffectPieceKingRelative::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:570
osl::PtypeO
PtypeO
Player + Ptype [-15, 15] PtypeO の O は Owner の O.
Definition: basic_type.h:199
osl::NumEffectState
利きを持つ局面
Definition: numEffectState.h:34
osl::Direction
Direction
Definition: basic_type.h:310
osl::eval::ml::RookEffectBase::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:254
osl::eval::ml::NumPiecesBetweenBishopAndKingSelf::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:801
osl::eval::ml::RookEffectBase::attack_nospace
static CArray< MultiInt, 722 > attack_nospace
Definition: majorPiece.h:264
osl::ROOK
@ ROOK
Definition: basic_type.h:100
osl::BoardTable::nextSquare
const Square nextSquare(Player P, Square pos, Direction dr) const
next position from pos for player P.
Definition: boardTable.h:61
osl::eval::ml::BishopSilverKnight::table
static CArray< MultiInt, ONE_DIM > table
Definition: majorPiece.h:680
osl::Square::canPromote
bool canPromote() const
Definition: basic_type.h:659
osl::effect::NumBitmapEffect
現在の定義 (2005/3/4以降)
Definition: numBitmapEffect.h:29
osl::Square::neighbor
const Square neighbor() const
Definition: basic_type.h:746
osl::SimpleState::kingSquare
Square kingSquare() const
Definition: simpleState.h:94
osl::Square::y
int y() const
将棋としてのY座標を返す.
Definition: basic_type.h:567
osl::eval::ml::BishopEffectBase::defense_dl
static CArray< MultiInt, 23104 > defense_dl
Definition: majorPiece.h:403
osl::eval::ml::RookEffectBase::defense_nospace
static CArray< MultiInt, 722 > defense_nospace
Definition: majorPiece.h:265
osl::MultiInt
QuadInt MultiInt
Definition: midgame.h:13
osl::eval::ml::BishopHead::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:707
osl::PTYPEO_MIN
@ PTYPEO_MIN
Definition: basic_type.h:200
osl::eval::ml::RookEffectBase::defense_u
static CArray< MultiInt, 23104 > defense_u
Definition: majorPiece.h:260
osl::eval::ml::MajorY
Definition: majorPiece.h:20
osl::eval::ml::BishopEffectBase::defense_dr
static CArray< MultiInt, 23104 > defense_dr
Definition: majorPiece.h:402
osl::eval::ml::BishopEffectBase::attack_table
static CArray< MultiInt, 612 > attack_table
Definition: majorPiece.h:393
osl::Piece::square
const Square square() const
Definition: basic_type.h:832
osl::PieceMask::any
bool any() const
Definition: pieceMask.h:57
osl::eval::ml::BishopEffectBase::attack_ul
static CArray< MultiInt, 23104 > attack_ul
Definition: majorPiece.h:397
osl::Piece::ptype
Ptype ptype() const
Definition: basic_type.h:821
osl::effect::NumBitmapEffect::countEffect
int countEffect(Player pl) const
Definition: numBitmapEffect.h:81
osl::Piece::isEmpty
bool isEmpty() const
Definition: basic_type.h:913
osl::eval::ml::BishopHead::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:664
osl::BLACK
@ BLACK
Definition: basic_type.h:9
osl::eval::ml::NumPiecesBetweenBishopAndKingOpp::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:812
osl::ptypeOIndex
unsigned int ptypeOIndex(PtypeO ptypeo)
Definition: basic_type.h:205
osl::eval::ml::RookEffectBase::attack_u
static CArray< MultiInt, 23104 > attack_u
Definition: majorPiece.h:256
osl::eval::ml::RookPawn::eval
static int eval(const NumEffectState &state)
Definition: majorPiece.cc:32
osl::eval::ml::RookPawnYX::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:60
osl::PTYPE_EDGE
@ PTYPE_EDGE
Definition: basic_type.h:86
osl::Piece::isPlayerPtype
bool isPlayerPtype(Player pl, Ptype ptype) const
あるpieceがPlayer pの持ち物でPtype ptypeであるかどうかをチェックする. TはEMPTY, EDGEではない.
Definition: basic_type.h:937
osl::PTYPEO_EMPTY
const PtypeO PTYPEO_EMPTY
Definition: basic_type.h:303
osl::DL
@ DL
Definition: basic_type.h:318
osl::Piece::isOnBoardNotPromoted
bool isOnBoardNotPromoted() const
promoteしていないOnBoardの駒であることのチェック Lance位しか使い道がない?
Definition: basic_type.h:904
osl::eval::ml::BishopHeadKingRelative::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:674
osl::eval::ml::RookRookPiece::table
static CArray< MultiInt, 128 > table
Definition: majorPiece.h:620
osl::Square::rotate180
const Square rotate180() const
Definition: basic_type.h:613
osl::eval::ml::NumPiecesBetweenBishopAndKingAll::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:823
osl::eval::ml::RookPawnY::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:74
osl::PTYPE_EMPTY
@ PTYPE_EMPTY
Definition: basic_type.h:85
osl::eval::ml::BishopEffectBase::defense_nospace
static CArray< MultiInt, 722 > defense_nospace
Definition: majorPiece.h:405
osl::Square::rotate180EdgeOK
const Square rotate180EdgeOK() const
Definition: basic_type.h:617
osl::SimpleState::turn
Player turn() const
Definition: simpleState.h:220
osl::eval::ml::MajorGoldSilverAttacked
Definition: majorPiece.h:136
osl::Player
Player
Definition: basic_type.h:8
osl::eval::ml::AttackMajorsInBase::addOne
static void addOne(const NumEffectState &state, Piece rook, MultiInt &)
Definition: majorPiece.cc:1439
osl::NumEffectState::hasEffectByPtype
bool hasEffectByPtype(Player attack, Square target) const
target に ptype の利きがあるか? 成不成を区別しない
Definition: numEffectState.h:355
osl::eval::ml::BishopEffectBase::attack_ur
static CArray< MultiInt, 23104 > attack_ur
Definition: majorPiece.h:396
osl::eval::ml::KingRookBishop::table
static CArray< MultiInt, 374544 > table
Definition: majorPiece.h:486
osl::UL
@ UL
Definition: basic_type.h:313
osl::eval::ml::BishopEffectBase::defense_ur
static CArray< MultiInt, 23104 > defense_ur
Definition: majorPiece.h:400
osl::CArray< int, 18 >
osl::eval::ml::RookPromoteDefense::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:378
osl::NumEffectState::mobilityOf
Square mobilityOf(Direction d, int num) const
Definition: numEffectState.h:175
osl::eval::ml::RookPromoteDefense::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:398
osl::eval::ml::MajorGoldSilverAttacked::index
static int index(const NumEffectState &state, Piece piece)
Definition: majorPiece.cc:148
osl::eval::ml::MajorY::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:12
osl::U
@ U
Definition: basic_type.h:314
majorPiece.h
osl::PieceMask
駒番号のビットセット.
Definition: pieceMask.h:21
osl::eval::ml::RookSilverKnight::table
static CArray< MultiInt, ONE_DIM > table
Definition: majorPiece.h:662
osl::Piece::isOnBoard
bool isOnBoard() const
Definition: basic_type.h:985
osl::eval::ml::RookPawnY::y_attack_table
static CArray< MultiInt, 1620 > y_attack_table
Definition: majorPiece.h:105
osl::NumEffectState::countEffect
int countEffect(Player player, Square target) const
利きの数を数える.
Definition: numEffectState.h:266
osl::Square::squareForBlack
const Square squareForBlack(Player player) const
Definition: basic_type.h:598
osl::eval::ml::BishopHeadX::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:697
osl::eval::ml::Weights::dimension
size_t dimension() const
Definition: weights.h:29
osl::eval::ml::RookEffectBase::defense_l
static CArray< MultiInt, 23104 > defense_l
Definition: majorPiece.h:262
osl::SimpleState::isPawnMaskSet
bool isPawnMaskSet(Player player, int x) const
Definition: simpleState.h:146
osl::NStages
const int NStages
Definition: midgame.h:11
osl::eval::ml::BishopSilverKnight::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:1343
osl::eval::ml::BishopEffect::setUp
static void setUp(const Weights &weights, int stage)
Definition: majorPiece.cc:550
osl
Definition: additionalEffect.h:6
osl::eval::ml::BishopEffectBase::attack_nospace
static CArray< MultiInt, 722 > attack_nospace
Definition: majorPiece.h:404
osl::eval::ml::NumPiecesBetweenBishopAndKing::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:834
osl::eval::ml::AttackMajorsInBase::setUp
static void setUp(const Weights &weights)
Definition: majorPiece.cc:1427
osl::eval::ml::KingRookBishop::eval
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:790