OSDev.org

Code: Select all

class cBoardPiece{
  public:
  int_fast32_t Move(sMove *from, sMove *to);
  int_fast32_t GetPossibleMoveVectors(sMove *array);
};

Code: Select all

struct sMove
{
  uint8_t x, y;
};

Code: Select all

class cBoard
{
  private:
  cBoardPiece *board;
  public:
  int_fast32_t PieceMove(sMove *from, sMove *to);
  int_fast32_t GetPossibleMoveVectors(sMove *for, sMove *array);
  cBoardPiece *GetPiece(uint_fast8_t x, uint_fast8_t y);
};

Code: Select all

Input
   edx:eax = bit mask for the encoded (X, Y) position we're interested in

Output
   ecx = piece number at this position (32 if the position is empty)

getPiece:
     xor ecx,ecx
.nextPiece:
     bt [is_it_alive_bitfield],ecx
     je .skip
     test [position_bitfield_table + ecx * 8], eax
     jne .done
     test [position_bitfield_table + ecx * 8 + 4], edx
     jne .done
.skip:
     inc ecx
     cmp ecx,32
     jb .nextPiece
.done:
     ret

Code: Select all

Input
   al = the encoded (X, Y) position we're interested in

Output
   esi = piece number at this position (32 if the position is empty)

getPiece:
     mov ecx,position_byte_table
.nextPiece:
     cmp [ecx],al
     je .done
     inc ecx
     cmp ecx,position_byte_table+32
     jb .nextPiece
.done:
     sub ecx,position_byte_table
     ret

Code: Select all

+--+--+--+
|b6|b7|b8|
+--+--+--+
|b3|b4|b5|
+--+--+--+
|b0|b1|b2|
+--+--+--+

Code: Select all

class T {
    enum {P, B, N, R, Q, K}; // just for the convinience of it.
    std::bitset<64> White[6], Black[6];
public:
  T() {
    for(int i = 1; i < 64; i += 8)
      White[P][i] = 1;
    for(int i = 6; i < 64; i += 8)
      Black[P][i] = 1;
    White[R][0] = 1;
    White[R][56] = 1;
    Black[R][7] = 1;
    Black[R][63] = 1;
    White[N][8] = 1;
    White[N][48] = 1;
    Black[N][15] = 1;
    Black[N][55] = 1;
    White[B][16] = 1;
    White[B][40] = 1;
    Black[B][23] = 1;
    Black[B][47] = 1;
    White[Q][24] = 1;
    Black[Q][31] = 1;
    White[K][32] = 1;
    Black[K][39] = 1;
  }
  ~T() {}
} BitBoard;

Code: Select all

std::bitset<64> a, b;
a = 0xffffffff00000000ll; // doesnt work, only the 32 least significant bits are affected.
b = 0xffffffffll << 32; // same story;

Code: Select all

class {
  enum {P, B, N, R, Q, K};
  unsigned long long White[6], Black[6];
public:
  void Init_Board() {
    White[P] = 0xff00ll;
    White[B] = 0x24ll;
    White[N] = 0x42ll;
    White[R] = 0x81ll;
    White[Q] = 0x08ll;
    White[K] = 0x10ll;
    Black[P] = 0xffll << 48;
    Black[B] = 0x24ll << 56;
    Black[N] = 0x42ll << 56;
    Black[R] = 0x81ll << 56;
    Black[Q] = 0x08ll << 56;
    Black[K] = 0x10ll << 56;
  }
  unsigned long long Get_White_Board() {
    return White[P] | White[B] | White[N] | White[R] | White[Q] | White[K];
  }
  unsigned long long Get_Black_Board() {
    return Black[P] | Black[B] | Black[N] | Black[R] | Black[Q] | Black[K];
  }
} BitBoard;

Code: Select all

  void Print_Board() {
    for(int i = 63; i >= 0; i--) {
      if (i % 8 == 7) std::cout << std::endl;
      if(White[P] & (1ll << i)) std::cout << " WP";
      else if(White[B] & (1ll << i)) std::cout << " WB";
      else if(White[N] & (1ll << i)) std::cout << " WN";
      else if(White[R] & (1ll << i)) std::cout << " WR";
      else if(White[Q] & (1ll << i)) std::cout << " WQ";
      else if(White[K] & (1ll << i)) std::cout << " WK";
      else if(Black[P] & (1ll << i)) std::cout << " BP";
      else if(Black[B] & (1ll << i)) std::cout << " BB";
      else if(Black[N] & (1ll << i)) std::cout << " BN";
      else if(Black[R] & (1ll << i)) std::cout << " BR";
      else if(Black[Q] & (1ll << i)) std::cout << " BQ";
      else if(Black[K] & (1ll << i)) std::cout << " BK";
      else std::cout << " --";
      if (i % 8 == 0) std::cout << std::endl;
    }
  }