dnomd343
/
klotski
mirror of https://github.com/dnomd343/klotski.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

refactor: clean up mover module

master
Dnomd343 10 months ago
parent
2795de0c71
commit
8d6322b50d
8 changed files with 63 additions and 435 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      src/core/CMakeLists.txt
  2. 339
      src/core/mover/internal/s2_demo.cc
  3. 26
      src/core/mover/internal/s2_hint_mover.cc
  4. 28
      src/core/mover/internal/s2_mover.cc
  5. 1
      src/core/mover/mover.h
  6. 66
      src/core/mover/s2_hint_mover.h
  7. 31
      src/core/mover/s2_mover.h
  8. 6
      src/core_test/mover/s2_mover.cc

1
src/core/CMakeLists.txt
View File

@ -88,7 +88,6 @@ set(KLSK_CORE_SRC
mover/internal/mover.cc
mover/internal/s2_mover.cc
mover/internal/s2_hint_mover.cc
mover/internal/s2_demo.cc
group/internal/group_union.cc
group/internal/group.cc

339
src/core/mover/internal/s2_demo.cc
View File

@ -1,339 +0,0 @@
#include "mover/s2_hint_mover.h"
#include <iostream>
#include "raw_code/raw_code.h"
using klotski::codec::RawCode;
using klotski::mover::S2HintMoverPro;
#define ADDR(N) ((N) * 3)
#define CAPTURE(code, N) (((code) >> ADDR(N)) & 0b111ULL)
#define MOVE_1x1(code, SRC, DST) \
((code) & ~(K_MASK_1x1_ << ADDR(SRC)) | (K_MASK_1x1 << ADDR(DST)))
#define MOVE_1x2(code, SRC, DST) \
((code) & ~(K_MASK_1x2_ << ADDR(SRC)) | (K_MASK_1x2 << ADDR(DST)))
#define MOVE_2x1(code, SRC, DST) \
((code) & ~(K_MASK_2x1_ << ADDR(SRC)) | (K_MASK_2x1 << ADDR(DST)))
#define MOVE_2x2(code, SRC, DST) \
((code) & ~(K_MASK_2x2_ << ADDR(SRC)) | (K_MASK_2x2 << ADDR(DST)))
#define RELEASE_1x1(code, SRC, DST, SP) \
release_(MOVE_1x1(code, SRC, DST), ((uint64_t)0b1 << (DST + 32)) | (SP))
#define RELEASE_1x2(code, SRC, DST, SP) \
release_(MOVE_1x2(code, SRC, DST), ((uint64_t)0b11 << (DST + 32)) | (SP))
#define RELEASE_2x1(code, SRC, DST, SP) \
release_(MOVE_2x1(code, SRC, DST), ((uint64_t)0b10001 << (DST + 32)) | (SP))
#define RELEASE_2x2(code, SRC, DST, SP) \
release_(MOVE_2x2(code, SRC, DST), ((uint64_t)0b110011 << (DST + 32)) | (SP))
#define MAYBE_UP(hint, N) (((hint) & (1 << ((N) - 4))) == 0)
#define MAYBE_DOWN(hint, N) (((hint) & (1 << ((N) + 4))) == 0)
#define MAYBE_LEFT(hint, N) (((hint) & (1 << ((N) - 1))) == 0)
#define MAYBE_RIGHT(hint, N) (((hint) & (1 << ((N) + 1))) == 0)
#define MAKE_SP(N) ((uint64_t)1 << (N))
template <int N>
void S2HintMoverPro::move_single(const uint64_t code, const uint32_t hint, const uint32_t kk) const {
if (N >= 4 && MAYBE_UP(hint, N)) { // case up
if (CAPTURE(code, N - 4) == BLOCK_1x1) {
RELEASE_1x1(code, N - 4, N, MAKE_SP(N - 4) | kk);
} else if (N >= 8 && CAPTURE(code, N - 8) == BLOCK_2x1) {
RELEASE_2x1(code, N - 8, N - 4, MAKE_SP(N - 8) | kk);
}
}
if (N < 16 && MAYBE_DOWN(hint, N)) { // case down
if (const uint8_t block = CAPTURE(code, N + 4); block == BLOCK_1x1) {
RELEASE_1x1(code, N + 4, N, MAKE_SP(N + 4) | kk);
} else if (N < 12 && block == BLOCK_2x1) {
RELEASE_2x1(code, N + 4, N, MAKE_SP(N + 8) | kk);
}
}
if (N % 4 >= 1 && MAYBE_LEFT(hint, N)) { // case left
if (CAPTURE(code, N - 1) == BLOCK_1x1) {
RELEASE_1x1(code, N - 1, N, MAKE_SP(N - 1) | kk);
} else if (N % 4 >= 2 && CAPTURE(code, N - 2) == BLOCK_1x2) {
RELEASE_1x2(code, N - 2, N - 1, MAKE_SP(N - 2) | kk);
}
}
if (N % 4 < 3 && MAYBE_RIGHT(hint, N)) { // case right
if (const uint8_t block = CAPTURE(code, N + 1); block == BLOCK_1x1) {
RELEASE_1x1(code, N + 1, N, MAKE_SP(N + 1) | kk);
} else if (N % 4 < 2 && block == BLOCK_1x2) {
RELEASE_1x2(code, N + 1, N, MAKE_SP(N + 2) | kk);
}
}
}
template <int N>
void S2HintMoverPro::move_double_h(const uint64_t code, const uint32_t hint) const {
do { // case up
if (N >= 4 && MAYBE_UP(hint, N)) {
if (const uint8_t block = CAPTURE(code, N - 4); block == BLOCK_1x1) { // left part
RELEASE_1x1(code, N - 4, N, MAKE_SP(N - 4) | MAKE_SP(N + 1));
RELEASE_1x1(code, N - 4, N + 1, MAKE_SP(N - 4) | MAKE_SP(N));
} else if (block == BLOCK_1x2) {
RELEASE_1x2(code, N - 4, N, MAKE_SP(N - 4) | MAKE_SP(N - 3));
break;
} else if (N >= 8 && block == BLOCK_fill) {
if (const uint8_t block_ = CAPTURE(code, N - 8); block_ == BLOCK_2x2) {
RELEASE_2x2(code, N - 8, N - 4, MAKE_SP(N - 8) | MAKE_SP(N - 7));
break;
} else if (block_ == BLOCK_2x1) {
RELEASE_2x1(code, N - 8, N - 4, MAKE_SP(N - 8) | MAKE_SP(N + 1));
}
}
if (!MAYBE_UP(hint, N + 1)) {
break;
}
if (const uint8_t block = CAPTURE(code, N - 3); block == BLOCK_1x1) { // right part
RELEASE_1x1(code, N - 3, N + 1, MAKE_SP(N) | MAKE_SP(N - 3));
RELEASE_1x1(code, N - 3, N, MAKE_SP(N - 3) | MAKE_SP(N + 1));
} else if (N >= 8 && block == BLOCK_fill && CAPTURE(code, N - 7) == BLOCK_2x1) {
RELEASE_2x1(code, N - 7, N - 3, MAKE_SP(N) | MAKE_SP(N - 7));
}
}
} while (false);
do { // case down
if (N < 16 && MAYBE_DOWN(hint, N)) {
if (const uint8_t block = CAPTURE(code, N + 4); block == BLOCK_1x1) { // left part
RELEASE_1x1(code, N + 4, N, MAKE_SP(N + 4) | MAKE_SP(N + 1));
RELEASE_1x1(code, N + 4, N + 1, MAKE_SP(N + 4) | MAKE_SP(N));
} else if (N < 12 && block == BLOCK_2x1) {
RELEASE_2x1(code, N + 4, N, MAKE_SP(N + 8) | MAKE_SP(N + 1));
} else if (block == BLOCK_1x2) {
RELEASE_1x2(code, N + 4, N, MAKE_SP(N + 4) | MAKE_SP(N + 5));
break;
} else if (N < 12 && block == BLOCK_2x2) {
RELEASE_2x2(code, N + 4, N, MAKE_SP(N + 8) | MAKE_SP(N + 9));
break;
}
if (!MAYBE_DOWN(hint, N + 1)) {
break;
}
if (const uint8_t block = CAPTURE(code, N + 5); block == BLOCK_1x1) { // right part
RELEASE_1x1(code, N + 5, N + 1, MAKE_SP(N) | MAKE_SP(N + 5));
RELEASE_1x1(code, N + 5, N, MAKE_SP(N + 1) | MAKE_SP(N + 5));
} else if (N < 12 && block == BLOCK_2x1) {
RELEASE_2x1(code, N + 5, N + 1, MAKE_SP(N) | MAKE_SP(N + 9));
}
}
} while (false);
if (N % 4 >= 1 && MAYBE_LEFT(hint, N)) { // case left
if (CAPTURE(code, N - 1) == BLOCK_1x1) {
RELEASE_1x1(code, N - 1, N, MAKE_SP(N - 1) | MAKE_SP(N + 1));
RELEASE_1x1(code, N - 1, N + 1, MAKE_SP(N - 1) | MAKE_SP(N));
} else if (N % 4 == 2 && CAPTURE(code, N - 2) == BLOCK_1x2) {
RELEASE_1x2(code, N - 2, N - 1, MAKE_SP(N - 2) | MAKE_SP(N + 1));
RELEASE_1x2(code, N - 2, N, MAKE_SP(N - 2) | MAKE_SP(N - 1));
}
}
if (N % 4 < 2 && MAYBE_RIGHT(hint, N + 1)) { // case right
if (const uint8_t block = CAPTURE(code, N + 2); block == BLOCK_1x1) {
RELEASE_1x1(code, N + 2, N + 1, MAKE_SP(N) | MAKE_SP(N + 2));
RELEASE_1x1(code, N + 2, N, MAKE_SP(N + 1) | MAKE_SP(N + 2));
} else if (N % 4 == 0 && block == BLOCK_1x2) {
RELEASE_1x2(code, N + 2, N + 1, MAKE_SP(N) | MAKE_SP(N + 3));
RELEASE_1x2(code, N + 2, N, MAKE_SP(N + 2) | MAKE_SP(N + 3));
}
}
}
template <int N>
void S2HintMoverPro::move_double_v(const uint64_t code, const uint32_t hint) const {
if (N >= 4 && MAYBE_UP(hint, N)) { // case up
if (CAPTURE(code, N - 4) == BLOCK_1x1) {
RELEASE_1x1(code, N - 4, N, MAKE_SP(N - 4) | MAKE_SP(N + 4));
RELEASE_1x1(code, N - 4, N + 4, MAKE_SP(N - 4) | MAKE_SP(N));
} else if (N >= 8 && CAPTURE(code, N - 8) == BLOCK_2x1) {
RELEASE_2x1(code, N - 8, N - 4, MAKE_SP(N - 8) | MAKE_SP(N + 4));
RELEASE_2x1(code, N - 8, N, MAKE_SP(N - 8) | MAKE_SP(N - 4));
}
}
if (N < 12 && MAYBE_DOWN(hint, N + 4)) { // case down
if (CAPTURE(code, N + 8) == BLOCK_1x1) {
RELEASE_1x1(code, N + 8, N + 4, MAKE_SP(N) | MAKE_SP(N + 8));
RELEASE_1x1(code, N + 8, N, MAKE_SP(N + 4) | MAKE_SP(N + 8));
} else if (N < 8 && CAPTURE(code, N + 8) == BLOCK_2x1) {
RELEASE_2x1(code, N + 8, N + 4, MAKE_SP(N) | MAKE_SP(N + 12));
RELEASE_2x1(code, N + 8, N, MAKE_SP(N + 8) | MAKE_SP(N + 12));
}
}
do { // case left
if (N % 4 != 0 && MAYBE_LEFT(hint, N)) {
if (const uint8_t block = CAPTURE(code, N - 1); block == BLOCK_1x1) { // up part
RELEASE_1x1(code, N - 1, N, MAKE_SP(N - 1) | MAKE_SP(N + 4));
RELEASE_1x1(code, N - 1, N + 4, MAKE_SP(N - 1) | MAKE_SP(N));
} else if (block == BLOCK_2x1) {
RELEASE_2x1(code, N - 1, N, MAKE_SP(N - 1) | MAKE_SP(N + 3));
break;
} else if (N % 4 >= 2 && block == BLOCK_fill) {
if (const uint8_t block_ = CAPTURE(code, N - 2); block_ == BLOCK_2x2) {
RELEASE_2x2(code, N - 2, N - 1, MAKE_SP(N - 2) | MAKE_SP(N + 2));
break;
} else if (block_ == BLOCK_1x2) {
RELEASE_1x2(code, N - 2, N - 1, MAKE_SP(N - 2) | MAKE_SP(N + 4));
}
}
if (!MAYBE_LEFT(hint, N + 4)) {
break;
}
if (const uint8_t block = CAPTURE(code, N + 3); block == BLOCK_1x1) { // down part
RELEASE_1x1(code, N + 3, N + 4, MAKE_SP(N) | MAKE_SP(N + 3));
RELEASE_1x1(code, N + 3, N, MAKE_SP(N + 3) | MAKE_SP(N + 4));
} else if (N % 4 >= 2 && block == BLOCK_fill && CAPTURE(code, N + 2) == BLOCK_1x2) {
RELEASE_1x2(code, N + 2, N + 3, MAKE_SP(N) | MAKE_SP(N + 2));
}
}
} while (false);
do { // case right
if (N % 4 < 3 && MAYBE_RIGHT(hint, N)) {
if (const uint8_t block = CAPTURE(code, N + 1); block == BLOCK_1x1) { // up part
RELEASE_1x1(code, N + 1, N, MAKE_SP(N + 4) | MAKE_SP(N + 1));
RELEASE_1x1(code, N + 1, N + 4, MAKE_SP(N) | MAKE_SP(N + 1));
} else if (N % 4 < 2 && block == BLOCK_1x2) {
RELEASE_1x2(code, N + 1, N, MAKE_SP(N + 2) | MAKE_SP(N + 4));
} else if (block == BLOCK_2x1) {
RELEASE_2x1(code, N + 1, N, MAKE_SP(N + 1) | MAKE_SP(N + 5));
break;
} else if (N % 4 < 2 && block == BLOCK_2x2) {
RELEASE_2x2(code, N + 1, N, MAKE_SP(N + 2) | MAKE_SP(N + 6));
break;
}
if (!MAYBE_RIGHT(hint, N + 4)) {
break;
}
if (const uint8_t block = CAPTURE(code, N + 5); block == BLOCK_1x1) { // down part
RELEASE_1x1(code, N + 5, N + 4, MAKE_SP(N) | MAKE_SP(N + 5));
RELEASE_1x1(code, N + 5, N, MAKE_SP(N + 4) | MAKE_SP(N + 5));
} else if (N % 4 < 2 && block == BLOCK_1x2) {
RELEASE_1x2(code, N + 5, N + 4, MAKE_SP(N) | MAKE_SP(N + 6));
}
}
} while (false);
}
void S2HintMoverPro::move_double_h(const uint64_t code, uint32_t hint, const int offset) const {
switch (offset) {
case 0: move_double_h<0>(code, hint); break;
case 1: move_double_h<1>(code, hint); break;
case 2: move_double_h<2>(code, hint); break;
case 4: move_double_h<4>(code, hint); break;
case 5: move_double_h<5>(code, hint); break;
case 6: move_double_h<6>(code, hint); break;
case 8: move_double_h<8>(code, hint); break;
case 9: move_double_h<9>(code, hint); break;
case 10: move_double_h<10>(code, hint); break;
case 12: move_double_h<12>(code, hint); break;
case 13: move_double_h<13>(code, hint); break;
case 14: move_double_h<14>(code, hint); break;
case 16: move_double_h<16>(code, hint); break;
case 17: move_double_h<17>(code, hint); break;
case 18: move_double_h<18>(code, hint); break;
default: std::unreachable();
}
}
void S2HintMoverPro::move_double_v(const uint64_t code, uint32_t hint, const int offset) const {
switch (offset) {
case 0: move_double_v<0>(code, hint); break;
case 1: move_double_v<1>(code, hint); break;
case 2: move_double_v<2>(code, hint); break;
case 3: move_double_v<3>(code, hint); break;
case 4: move_double_v<4>(code, hint); break;
case 5: move_double_v<5>(code, hint); break;
case 6: move_double_v<6>(code, hint); break;
case 7: move_double_v<7>(code, hint); break;
case 8: move_double_v<8>(code, hint); break;
case 9: move_double_v<9>(code, hint); break;
case 10: move_double_v<10>(code, hint); break;
case 11: move_double_v<11>(code, hint); break;
case 12: move_double_v<12>(code, hint); break;
case 13: move_double_v<13>(code, hint); break;
case 14: move_double_v<14>(code, hint); break;
case 15: move_double_v<15>(code, hint); break;
default: std::unreachable();
}
}
void S2HintMoverPro::move_single(const uint64_t code, uint32_t hint, const int offset, int offset_) const {
uint64_t kk = MAKE_SP(offset_);
switch (offset) {
case 0: move_single<0>(code, hint, kk); break;
case 1: move_single<1>(code, hint, kk); break;
case 2: move_single<2>(code, hint, kk); break;
case 3: move_single<3>(code, hint, kk); break;
case 4: move_single<4>(code, hint, kk); break;
case 5: move_single<5>(code, hint, kk); break;
case 6: move_single<6>(code, hint, kk); break;
case 7: move_single<7>(code, hint, kk); break;
case 8: move_single<8>(code, hint, kk); break;
case 9: move_single<9>(code, hint, kk); break;
case 10: move_single<10>(code, hint, kk); break;
case 11: move_single<11>(code, hint, kk); break;
case 12: move_single<12>(code, hint, kk); break;
case 13: move_single<13>(code, hint, kk); break;
case 14: move_single<14>(code, hint, kk); break;
case 15: move_single<15>(code, hint, kk); break;
case 16: move_single<16>(code, hint, kk); break;
case 17: move_single<17>(code, hint, kk); break;
case 18: move_single<18>(code, hint, kk); break;
case 19: move_single<19>(code, hint, kk); break;
default: std::unreachable();
}
}
void S2HintMoverPro::next_cases(const uint64_t code, const uint64_t hint) const {
// const uint64_t mask = code | (code >> 1) | (code >> 2) | 0xFDB6DB6DB6DB6DB6;
// const int space_a = std::countr_one(mask) / 3;
// const int space_b = (63 - std::countl_one(mask)) / 3;
const uint32_t tmp = hint;
const int space_a_ = std::countr_zero(tmp);
const int space_b_ = 31 - std::countl_zero(tmp);
// if (space_a != space_a_) {
// std::cout << "error: " << RawCode::unsafe_create(code).to_common_code() << std::endl;
// }
// if (space_b != space_b_) {
// std::cout << "error" << RawCode::unsafe_create(code).to_common_code() << std::endl;
// }
const uint32_t hint_ = hint >> 32;
if (space_a_ + 1 == space_b_ && space_a_ % 4 != 3) {
move_double_h(code, hint_, space_a_);
} else if (space_a_ + 4 == space_b_) {
move_double_v(code, hint_, space_a_);
} else {
move_single(code, hint_, space_a_, space_b_);
move_single(code, hint_, space_b_, space_a_);
}
}
uint64_t S2HintMoverPro::make_hint(const uint64_t code) {
const uint64_t mask = code | (code >> 1) | (code >> 2) | 0xFDB6DB6DB6DB6DB6;
const int space_a = std::countr_one(mask) / 3;
const int space_b = (63 - std::countl_one(mask)) / 3;
return MAKE_SP(space_a) | MAKE_SP(space_b);
}

26
src/core/mover/internal/s2_hint_mover.cc
View File

@ -1,9 +1,12 @@
#include "mover/s2_hint_mover.h"
#include "mover/mover.h"
#include "raw_code/raw_code.h"
using klotski::codec::RawCode;
using klotski::mover::S2HintMover;
// TODO: using `CAPTURE(N + xxx)` instead of `CAPTURE(code, N + xxx)`
// also for `RELEASE_xxx` and `MAYBE_xxx`
#define ADDR(N) ((N) * 3)
#define CAPTURE(code, N) (((code) >> ADDR(N)) & 0b111ULL)
@ -21,16 +24,16 @@ using klotski::mover::S2HintMover;
((code) & ~(K_MASK_2x2_ << ADDR(SRC)) | (K_MASK_2x2 << ADDR(DST)))
#define RELEASE_1x1(code, SRC, DST) \
release_(MOVE_1x1(code, SRC, DST), (0b1 << (DST)))
release_(RawCode::unsafe_create(MOVE_1x1(code, SRC, DST)), (0b1 << (DST)))
#define RELEASE_1x2(code, SRC, DST) \
release_(MOVE_1x2(code, SRC, DST), (0b11 << (DST)))
release_(RawCode::unsafe_create(MOVE_1x2(code, SRC, DST)), (0b11 << (DST)))
#define RELEASE_2x1(code, SRC, DST) \
release_(MOVE_2x1(code, SRC, DST), (0b10001 << (DST)))
release_(RawCode::unsafe_create(MOVE_2x1(code, SRC, DST)), (0b10001 << (DST)))
#define RELEASE_2x2(code, SRC, DST) \
release_(MOVE_2x2(code, SRC, DST), (0b110011 << (DST)))
release_(RawCode::unsafe_create(MOVE_2x2(code, SRC, DST)), (0b110011 << (DST)))
#define MAYBE_UP(hint, N) (((hint) & (1 << ((N) - 4))) == 0)
@ -298,17 +301,18 @@ void S2HintMover::move_single(const uint64_t code, uint64_t hint, const int offs
}
}
void S2HintMover::next_cases(const uint64_t code, const uint64_t hint) const {
const uint64_t mask = code | (code >> 1) | (code >> 2) | 0xFDB6DB6DB6DB6DB6;
void S2HintMover::next_cases(const RawCode code, const uint64_t hint) const {
uint64_t code_ = code.unwrap();
const uint64_t mask = code_ | (code_ >> 1) | (code_ >> 2) | 0xFDB6DB6DB6DB6DB6;
const int space_a = std::countr_one(mask) / 3;
const int space_b = (63 - std::countl_one(mask)) / 3;
if (space_a + 1 == space_b && space_a % 4 != 3) {
move_double_h(code, hint, space_a);
move_double_h(code_, hint, space_a);
} else if (space_a + 4 == space_b) {
move_double_v(code, hint, space_a);
move_double_v(code_, hint, space_a);
} else {
move_single(code, hint, space_a);
move_single(code, hint, space_b);
move_single(code_, hint, space_a);
move_single(code_, hint, space_b);
}
}

28
src/core/mover/internal/s2_mover.cc
View File

@ -1,8 +1,11 @@
#include "mover/s2_mover.h"
#include "mover/mover.h"
#include "raw_code/raw_code.h"
using klotski::mover::S2Mover;
using klotski::codec::RawCode;
using klotski::mover::S2Mover;
// TODO: using `CAPTURE(N + xxx)` instead of `CAPTURE(code, N + xxx)`
// also for `RELEASE_xxx`
#define ADDR(N) ((N) * 3)
@ -20,13 +23,13 @@ using klotski::codec::RawCode;
#define MOVE_2x2(code, SRC, DST) \
((code) & ~(K_MASK_2x2_ << ADDR(SRC)) | (K_MASK_2x2 << ADDR(DST)))
#define RELEASE_1x1(code, SRC, DST) release_(MOVE_1x1(code, SRC, DST))
#define RELEASE_1x1(code, SRC, DST) release_(RawCode::unsafe_create(MOVE_1x1(code, SRC, DST)))
#define RELEASE_1x2(code, SRC, DST) release_(MOVE_1x2(code, SRC, DST))
#define RELEASE_1x2(code, SRC, DST) release_(RawCode::unsafe_create(MOVE_1x2(code, SRC, DST)))
#define RELEASE_2x1(code, SRC, DST) release_(MOVE_2x1(code, SRC, DST))
#define RELEASE_2x1(code, SRC, DST) release_(RawCode::unsafe_create(MOVE_2x1(code, SRC, DST)))
#define RELEASE_2x2(code, SRC, DST) release_(MOVE_2x2(code, SRC, DST))
#define RELEASE_2x2(code, SRC, DST) release_(RawCode::unsafe_create(MOVE_2x2(code, SRC, DST)))
template <int N>
void S2Mover::move_single(const uint64_t code) const {
@ -274,17 +277,18 @@ void S2Mover::move_single(const uint64_t code, const int offset) const {
}
}
void S2Mover::next_cases(const uint64_t code) const {
const uint64_t mask = code | (code >> 1) | (code >> 2) | 0xFDB6DB6DB6DB6DB6;
void S2Mover::next_cases(const RawCode code) const {
uint64_t code_ = code.unwrap();
const uint64_t mask = code_ | (code_ >> 1) | (code_ >> 2) | 0xFDB6DB6DB6DB6DB6;
const int space_a = std::countr_one(mask) / 3;
const int space_b = (63 - std::countl_one(mask)) / 3;
if (space_a + 1 == space_b && space_a % 4 != 3) {
move_double_h(code, space_a);
move_double_h(code_, space_a);
} else if (space_a + 4 == space_b) {
move_double_v(code, space_a);
move_double_v(code_, space_a);
} else {
move_single(code, space_a);
move_single(code, space_b);
move_single(code_, space_a);
move_single(code_, space_b);
}
}

1
src/core/mover/mover.h
View File

@ -100,4 +100,3 @@ private:
} // namespace klotski::mover
#include "s2_mover.h"
#include "s2_hint_mover.h"

66
src/core/mover/s2_hint_mover.h
View File

@ -1,66 +0,0 @@
#pragma once
#include <functional>
namespace klotski::mover {
class S2HintMover {
public:
using release_t = std::function<void(uint64_t, uint64_t)>;
explicit S2HintMover(release_t release_func) : release_(std::move(release_func)) {}
void next_cases(uint64_t code, uint64_t hint) const;
private:
release_t release_;
template <int N>
void move_single(uint64_t code, uint64_t hint) const;
template <int N>
void move_double_h(uint64_t code, uint64_t hint) const;
template <int N>
void move_double_v(uint64_t code, uint64_t hint) const;
void move_single(uint64_t code, uint64_t hint, int offset) const;
void move_double_h(uint64_t code, uint64_t hint, int offset) const;
void move_double_v(uint64_t code, uint64_t hint, int offset) const;
};
} // namespace klotski::mover
namespace klotski::mover {
// TODO: It seems that storage space in `hint` will cause performance
// degradation, maybe remove this optimization.
class S2HintMoverPro {
public:
using release_t = std::function<void(uint64_t, uint64_t)>;
explicit S2HintMoverPro(release_t release_func) : release_(std::move(release_func)) {}
void next_cases(uint64_t code, uint64_t hint) const;
static uint64_t make_hint(uint64_t code);
private:
release_t release_;
template <int N>
void move_single(uint64_t code, uint32_t hint, uint32_t kk) const;
template <int N>
void move_double_h(uint64_t code, uint32_t hint) const;
template <int N>
void move_double_v(uint64_t code, uint32_t hint) const;
void move_single(uint64_t code, uint32_t hint, int offset, int offset_) const;
void move_double_h(uint64_t code, uint32_t hint, int offset) const;
void move_double_v(uint64_t code, uint32_t hint, int offset) const;
};
} // namespace klotski::mover

31
src/core/mover/s2_mover.h
View File

@ -2,15 +2,17 @@
#include <functional>
#include "raw_code/raw_code_fwd.h"
namespace klotski::mover {
class S2Mover {
public:
using release_t = std::function<void(uint64_t)>;
using release_t = std::function<void(codec::RawCode)>;
explicit S2Mover(release_t release_func) : release_(std::move(release_func)) {}
void next_cases(uint64_t code) const;
void next_cases(codec::RawCode code) const;
private:
release_t release_;
@ -29,4 +31,29 @@ private:
void move_double_v(uint64_t code, int offset) const;
};
class S2HintMover {
public:
using release_t = std::function<void(codec::RawCode, uint64_t)>;
explicit S2HintMover(release_t release_func) : release_(std::move(release_func)) {}
void next_cases(codec::RawCode code, uint64_t hint) const;
private:
release_t release_;
template <int N>
void move_single(uint64_t code, uint64_t hint) const;
template <int N>
void move_double_h(uint64_t code, uint64_t hint) const;
template <int N>
void move_double_v(uint64_t code, uint64_t hint) const;
void move_single(uint64_t code, uint64_t hint, int offset) const;
void move_double_h(uint64_t code, uint64_t hint, int offset) const;
void move_double_v(uint64_t code, uint64_t hint, int offset) const;
};
} // namespace klotski::mover

6
src/core_test/mover/s2_mover.cc
View File

@ -27,12 +27,12 @@ TEST(S2Mover, demo) {
auto s2_mover = [](RawCode src) {
std::vector<uint64_t> results {};
auto mover = S2Mover([&results](uint64_t code) {
auto mover = S2Mover([&results](RawCode code) {
// std::cout << RawCode::unsafe_create(code) << std::endl;
EXPECT_TRUE(RawCode::check(code));
EXPECT_TRUE(RawCode::check(code.unwrap()));
results.emplace_back(code);
});
mover.next_cases(src.unwrap());
mover.next_cases(src);
std::ranges::sort(results.begin(), results.end());
return results;
};

Write Preview
Loading…
Cancel
Save