11 DirectionPlayerTraits<UUL, BLACK>::offset(),
12 DirectionPlayerTraits<UL, BLACK>::offset(),
13 DirectionPlayerTraits<L, BLACK>::offset(),
14 DirectionPlayerTraits<DL, BLACK>::offset(),
15 DirectionPlayerTraits<UUR, WHITE>::offset(),
16 DirectionPlayerTraits<D, BLACK>::offset(),
18 DirectionPlayerTraits<UUL, WHITE>::offset(),
19 DirectionPlayerTraits<DR, BLACK>::offset(),
20 DirectionPlayerTraits<R, BLACK>::offset(),
21 DirectionPlayerTraits<UR, BLACK>::offset(),
22 DirectionPlayerTraits<UUR, BLACK>::offset(),
23 DirectionPlayerTraits<U, BLACK>::offset(),
46 inline int inv(
int offset_id)
48 assert(offset_id >= 0 && offset_id < 12);
49 return (offset_id + 6) % 12;
53 assert(offset_id >= 0 && offset_id < 12);
56 return 10 - offset_id;
60 assert(offset_id >= 0 && offset_id < 12);
68 for (
int ip1=ip0; ip1<=
PTYPE_MAX; ++ip1) {
69 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
150 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
152 for (
int x=1; x<=5; ++x) {
154 for (
int d=0; d<2; ++d) {
156 x_table[x][d][pi0][pi1] = index;
161 x_table[x][2][pi0][pi1] = index;
164 x_table[x][11][pi0][pi1] = index;
167 x_table[x][5][pi0][pi1] = index;
175 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
177 for (
int x=2; x<=5; ++x) {
179 for (
int d=0; d<2; ++d) {
197 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
199 for (
int x=6; x<=9; ++x) {
207 for (
int x=1; x<=9; ++x) {
210 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
214 assert(
x_table[x][d][pi0][pi1]);
221 for (
int x=1; x<=9; ++x)
235 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
238 for (
int y=1; y<=9; ++y) {
239 for (
int d=0; d<2; ++d) {
241 y_table[y][d][pi0][pi1] = index;
246 y_table[y][2][pi0][pi1] = index;
247 y_table[y][2][pi1][pi0] = index;
252 y_table[y][11][pi0][pi1] = index;
259 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
261 for (
int y=1; y<=9; ++y) {
276 const Ptype p0 =
static_cast<Ptype>(ip0), p1 = static_cast<Ptype>(ip1);
279 for (
int y=1; y<=9; ++y) {
287 for (
int y=1; y<=9; ++y)
293 using namespace ppair;
308 for (
size_t d=0; d<offsets.size(); ++d) {
311 signed short&
target = (*this)[d][ip0][ip1];
329 (*this)[dir][pi0][pi1] = index;
330 (*this)[
inv(dir)][pi0w][pi1w] = -index;
335 fillBW(index, dir, p0, p1);
336 fillBW(index,
inv(dir), p1, p0);
344 (*this)[
inv(dir)][pi0][pi1w] = index;
345 (*this)[dir][pi1w][pi0] = index;
346 (*this)[
inv(dir)][pi1][pi0w] = -index;
347 (*this)[dir][pi0w][pi1] = -index;
355 static bool initialized =
false;
368 for (
int i=1; i<=9; ++i) {
372 for (
size_t d=0; d<offsets.size(); ++d) {
380 for (
int i=1; i<=9; ++i) {
382 if (
x_table[i][d][ip0][ip1] > 0)
384 else if (
x_table[i][d][ip0][ip1] < 0)
386 if (
y_table[i][d][ip0][ip1] > 0)
388 else if (
y_table[i][d][ip0][ip1] < 0)
400 for (
int x=1; x<=9; ++x) {
401 for (
int y=1; y<=9; ++y) {
403 for (
size_t i=0; i<offsets.size(); ++i) {
404 const Square pos0 = pos1+offsets[i];
423 assert(pos0 != pos1);
426 assert(pos0 - pos1 == offsets[offset_id]);
432 assert(abs(ret[0]) < plain_table_size);
433 assert(abs(ret[1]) < plain_table_size + x_table_size);
434 assert(abs(ret[2]) < plain_table_size + x_table_size + y_table_size);
435 assert(ret[1] == 0 || abs(ret[1]) > plain_table_size);
436 assert(ret[2] == 0 || abs(ret[2]) > plain_table_size + x_table_size);
455 const Piece p = state.pieceOf(i);
456 ret += pieceValueDouble(state, p, values);
467 int ret = last_value;
473 for (
size_t i=0; i<offsets.size(); ++i) {
475 const Piece p = state.pieceAt(target);
479 ret -= value(i, p, from, moved.
oldPtypeO(), values);
486 for (
size_t i=0; i<offsets.size(); ++i) {
488 const Piece p = state.pieceAt(target);
492 ret += value(i, p, to, moved.
ptypeO(), values);
498 for (
size_t i=0; i<offsets.size(); ++i) {
500 const Piece p = state.pieceAt(target);
504 ret += value(i, p, to, moved.
ptypeO(), values);
509 const Offset diff = to - from;
520 assert(pos0 != pos1);
522 assert(pos0 - pos1 == offsets[offset_id]);
528 template <
int Direction,
int Offset>
543 const Piece* base_ptr= state.getPiecePtr(base);
545 sum12One<4,18>(base_ptr,xbase,ybase)+
546 + sum12One<3,17>(base_ptr,xbase,ybase)
547 + sum12One<2,16>(base_ptr,xbase,ybase)
548 + sum12One<1,15>(base_ptr,xbase,ybase)
549 + sum12One<0,14>(base_ptr,xbase,ybase)
550 + sum12One<5,1>(base_ptr,xbase,ybase)
551 + sum12One<11,-1>(base_ptr,xbase,ybase)
552 + sum12One<6,-14>(base_ptr,xbase,ybase)
553 + sum12One<7,-15>(base_ptr,xbase,ybase)
554 + sum12One<8,-16>(base_ptr,xbase,ybase)
555 + sum12One<9,-17>(base_ptr,xbase,ybase)
556 + sum12One<10,-18>(base_ptr,xbase,ybase);
559 template<
int Direction,
int Offset>
579 const Piece* base_ptr= state.getPiecePtr(base);
581 adjust12One<4,18>(base_ptr,xbase1,ybase1,xbase2,ybase2)
582 + adjust12One<3,17>(base_ptr,xbase1,ybase1,xbase2,ybase2)
583 + adjust12One<2,16>(base_ptr,xbase1,ybase1,xbase2,ybase2)
584 + adjust12One<1,15>(base_ptr,xbase1,ybase1,xbase2,ybase2)
585 + adjust12One<0,14>(base_ptr,xbase1,ybase1,xbase2,ybase2)
586 + adjust12One<5,1>(base_ptr,xbase1,ybase1,xbase2,ybase2)
587 + adjust12One<11,-1>(base_ptr,xbase1,ybase1,xbase2,ybase2)
588 + adjust12One<6,-14>(base_ptr,xbase1,ybase1,xbase2,ybase2)
589 + adjust12One<7,-15>(base_ptr,xbase1,ybase1,xbase2,ybase2)
590 + adjust12One<8,-16>(base_ptr,xbase1,ybase1,xbase2,ybase2)
591 + adjust12One<9,-17>(base_ptr,xbase1,ybase1,xbase2,ybase2)
592 + adjust12One<10,-18>(base_ptr,xbase1,ybase1,xbase2,ybase2);
598 int ret = last_value;
604 ret+=sum12(state,to,moved.
ptypeO());
608 ret-=sum12(state,from,moved.
oldPtypeO());
611 ret+=sum12(state,to,moved.
ptypeO());
612 const Offset diff = to-from;
628 const Offset diff = to-from;
656 for (
size_t i=0; i<offsets.size(); ++i) {
658 const Piece q = state.pieceAt(target);
663 int v = value(i, q, p, values);
672 return pieceValueDouble(state, p, values)/2;