reversi 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f21066f809daeaccbfdfbc19f61dc5ac79b0dbca
-  data.tar.gz: dca98c6b7c7f64ae612e35dd3a218a9993b35434
+  metadata.gz: 0595624ced91db908b4f67fa83459a6f31e1f9ec
+  data.tar.gz: b32155cc37fa7816d0eceb7b2b97102934568ebc
 SHA512:
-  metadata.gz: 0b6798e66984df642eb6fec17b0bf88a6d37d21c10b909558d6ca069a0fab63e347a76fc01106cf7993bf23f468c62da060a296341792b1058bedaa682d4eaee
-  data.tar.gz: ae1a412572613d73f47b75aed52c63211f50b90d2a3a0f22d7a8d86a7b9dcf586553d25bf2792b708eb4215c864513c102febc43519eae4ce241c194fdd529e1
+  metadata.gz: 3eee7c4c79aad77ba5bcc665786498f7fc62c2fac0484d6c3537e52c7520a7dfc1072f5141aad1665f52e63b9a4fa5ed2211c4e06b6eda77dec948590ef78d4d
+  data.tar.gz: 535dcd06b6426edab71f8f74597e38a4ae84e24915a2a32b0377d281704bdadc1aac42b17a125165fd4b7dd0b8bdb46a0b922eb83988b6b1f4564bb7aa2d1f21

data/README.md

@@ -83,20 +83,21 @@ game.start
 
 You can make your original player class by inheriting `Reversi::Player::BasePlayer` and defining `move` method.  
 
-`next_moves` method returns an array of the next moves information. A player places a supplied color's disk on specified position, and flips the opponent's disks by using `put_disk` method. You can get the current game board state from a `board` variable or `status` method.
+`next_moves` method returns an array of the next moves. A player places a supplied color's disk on specified position, and flips the opponent's disks by using `put_disk` method. You can get the current game board state from a `board` variable or `status` method.
 
  * **Example of Random Player**
 
 ```ruby
 class MyAI < Reversi::Player::BasePlayer
   def move(board)
-    moves = next_moves.map{ |v| v[:move] }
+    moves = next_moves
     put_disk(*moves.sample) unless moves.empty?
   end
 end
 
 Reversi.configure do |config|
   config.player_b = MyAI
+  config.progress = true
 end
 
 game = Reversi::Game.new
@@ -127,7 +128,7 @@ class MyAI < Reversi::Player::BasePlayer
   end
 
   def move(board)
-    moves = next_moves.map{ |v| v[:move] }
+    moves = next_moves
     return if moves.empty?
     next_move = moves.map do |move|
       { :move => move, :point => evaluate(move, board, 3, true) }
@@ -140,7 +141,7 @@ class MyAI < Reversi::Player::BasePlayer
     put_disk(*move, color)
 
     # Acquire the branches of this node.
-    moves = next_moves(!color).map{ |v| v[:move] }
+    moves = next_moves(!color)
 
     # Evaluate a current game-state when a search reaches the leaf node.
     if depth == 1
@@ -167,6 +168,7 @@ end
 
 Reversi.configure do |config|
   config.player_b = MyAI
+  config.progress = true
 end
 
 game = Reversi::Game.new

data/ext/reversi/bit_board_functions.c

@@ -0,0 +1,226 @@
+#include "bit_board_functions.h"
+
+unsigned long XY2BB(int x, int y) {
+  return (unsigned long)1 << ((8-x) + (8-y) * 8);
+}
+
+VALUE BB2XY(unsigned long bb) {
+  VALUE xy = rb_ary_new();
+
+  switch(bb) {
+    case 0x8000000000000000: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(1)); break;
+    case 0x4000000000000000: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(1)); break;
+    case 0x2000000000000000: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(1)); break;
+    case 0x1000000000000000: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(1)); break;
+    case 0x0800000000000000: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(1)); break;
+    case 0x0400000000000000: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(1)); break;
+    case 0x0200000000000000: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(1)); break;
+    case 0x0100000000000000: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(1)); break;
+
+    case 0x0080000000000000: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(2)); break;
+    case 0x0040000000000000: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(2)); break;
+    case 0x0020000000000000: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(2)); break;
+    case 0x0010000000000000: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(2)); break;
+    case 0x0008000000000000: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(2)); break;
+    case 0x0004000000000000: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(2)); break;
+    case 0x0002000000000000: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(2)); break;
+    case 0x0001000000000000: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(2)); break;
+
+    case 0x0000800000000000: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(3)); break;
+    case 0x0000400000000000: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(3)); break;
+    case 0x0000200000000000: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(3)); break;
+    case 0x0000100000000000: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(3)); break;
+    case 0x0000080000000000: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(3)); break;
+    case 0x0000040000000000: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(3)); break;
+    case 0x0000020000000000: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(3)); break;
+    case 0x0000010000000000: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(3)); break;
+
+    case 0x0000008000000000: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(4)); break;
+    case 0x0000004000000000: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(4)); break;
+    case 0x0000002000000000: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(4)); break;
+    case 0x0000001000000000: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(4)); break;
+    case 0x0000000800000000: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(4)); break;
+    case 0x0000000400000000: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(4)); break;
+    case 0x0000000200000000: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(4)); break;
+    case 0x0000000100000000: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(4)); break;
+
+    case 0x0000000080000000: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(5)); break;
+    case 0x0000000040000000: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(5)); break;
+    case 0x0000000020000000: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(5)); break;
+    case 0x0000000010000000: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(5)); break;
+    case 0x0000000008000000: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(5)); break;
+    case 0x0000000004000000: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(5)); break;
+    case 0x0000000002000000: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(5)); break;
+    case 0x0000000001000000: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(5)); break;
+
+    case 0x0000000000800000: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(6)); break;
+    case 0x0000000000400000: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(6)); break;
+    case 0x0000000000200000: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(6)); break;
+    case 0x0000000000100000: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(6)); break;
+    case 0x0000000000080000: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(6)); break;
+    case 0x0000000000040000: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(6)); break;
+    case 0x0000000000020000: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(6)); break;
+    case 0x0000000000010000: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(6)); break;
+
+    case 0x0000000000008000: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(7)); break;
+    case 0x0000000000004000: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(7)); break;
+    case 0x0000000000002000: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(7)); break;
+    case 0x0000000000001000: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(7)); break;
+    case 0x0000000000000800: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(7)); break;
+    case 0x0000000000000400: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(7)); break;
+    case 0x0000000000000200: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(7)); break;
+    case 0x0000000000000100: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(7)); break;
+
+    case 0x0000000000000080: rb_ary_push(xy, INT2FIX(1)), rb_ary_push(xy, INT2FIX(8)); break;
+    case 0x0000000000000040: rb_ary_push(xy, INT2FIX(2)), rb_ary_push(xy, INT2FIX(8)); break;
+    case 0x0000000000000020: rb_ary_push(xy, INT2FIX(3)), rb_ary_push(xy, INT2FIX(8)); break;
+    case 0x0000000000000010: rb_ary_push(xy, INT2FIX(4)), rb_ary_push(xy, INT2FIX(8)); break;
+    case 0x0000000000000008: rb_ary_push(xy, INT2FIX(5)), rb_ary_push(xy, INT2FIX(8)); break;
+    case 0x0000000000000004: rb_ary_push(xy, INT2FIX(6)), rb_ary_push(xy, INT2FIX(8)); break;
+    case 0x0000000000000002: rb_ary_push(xy, INT2FIX(7)), rb_ary_push(xy, INT2FIX(8)); break;
+    case 0x0000000000000001: rb_ary_push(xy, INT2FIX(8)), rb_ary_push(xy, INT2FIX(8)); break;
+  }
+  return xy;
+}
+
+unsigned long rotate_r90(unsigned long bb) {
+  bb = ((bb <<  8) & 0xAA00AA00AA00AA00) |
+       ((bb >>  8) & 0x0055005500550055) |
+       ((bb <<  1) & 0x00AA00AA00AA00AA) |
+       ((bb >>  1) & 0x5500550055005500);
+  bb = ((bb << 16) & 0xCCCC0000CCCC0000) |
+       ((bb >> 16) & 0x0000333300003333) |
+       ((bb <<  2) & 0x0000CCCC0000CCCC) |
+       ((bb >>  2) & 0x3333000033330000);
+  bb = ((bb << 32) & 0xF0F0F0F000000000) |
+       ((bb >> 32) & 0x000000000F0F0F0F) |
+       ((bb <<  4) & 0x00000000F0F0F0F0) |
+       ((bb >>  4) & 0x0F0F0F0F00000000);
+  return bb;
+}
+
+unsigned long rotate_l90(unsigned long bb) {
+  bb = ((bb <<  1) & 0xAA00AA00AA00AA00) |
+       ((bb >>  1) & 0x0055005500550055) |
+       ((bb >>  8) & 0x00AA00AA00AA00AA) |
+       ((bb <<  8) & 0x5500550055005500);
+  bb = ((bb <<  2) & 0xCCCC0000CCCC0000) |
+       ((bb >>  2) & 0x0000333300003333) |
+       ((bb >> 16) & 0x0000CCCC0000CCCC) |
+       ((bb << 16) & 0x3333000033330000);
+  bb = ((bb <<  4) & 0xF0F0F0F000000000) |
+       ((bb >>  4) & 0x000000000F0F0F0F) |
+       ((bb >> 32) & 0x00000000F0F0F0F0) |
+       ((bb << 32) & 0x0F0F0F0F00000000);
+  return bb;
+}
+
+unsigned long rotate_r45(unsigned long bb) {
+  bb = (bb & 0x0101010101010101) |
+       (((bb <<  8) | (bb >> 56)) & 0x0202020202020202) |
+       (((bb << 16) | (bb >> 48)) & 0x0404040404040404) |
+       (((bb << 24) | (bb >> 40)) & 0x0808080808080808) |
+       (((bb << 32) | (bb >> 32)) & 0x1010101010101010) |
+       (((bb << 40) | (bb >> 24)) & 0x2020202020202020) |
+       (((bb << 48) | (bb >> 16)) & 0x4040404040404040) |
+       (((bb << 56) | (bb >>  8)) & 0x8080808080808080);
+  return bb;
+}
+
+unsigned long rotate_l45(unsigned long bb) {
+  bb = (bb & 0x0101010101010101) |
+       (((bb >>  8) | (bb << 56)) & 0x0202020202020202) |
+       (((bb >> 16) | (bb << 48)) & 0x0404040404040404) |
+       (((bb >> 24) | (bb << 40)) & 0x0808080808080808) |
+       (((bb >> 32) | (bb << 32)) & 0x1010101010101010) |
+       (((bb >> 40) | (bb << 24)) & 0x2020202020202020) |
+       (((bb >> 48) | (bb << 16)) & 0x4040404040404040) |
+       (((bb >> 56) | (bb <<  8)) & 0x8080808080808080);
+  return bb;
+}
+
+unsigned long horizontal_pat(unsigned long my, unsigned long op, unsigned long p) {
+  op &= 0x7E7E7E7E7E7E7E7E;
+  return right_pat(my, op, p) | left_pat(my, op, p);
+}
+
+unsigned long vertical_pat(unsigned long my, unsigned long op, unsigned long p) {
+  my = rotate_r90(my);
+  op = rotate_r90(op & 0x00FFFFFFFFFFFF00);
+  p  = rotate_r90(p);
+  return rotate_l90(right_pat(my, op, p) | left_pat(my, op, p));
+}
+
+unsigned long diagonal_pat(unsigned long my, unsigned long op, unsigned long p) {
+  unsigned long my_r45 = rotate_r45(my);
+  unsigned long op_r45 = rotate_r45(op & 0x007E7E7E7E7E7E00);
+  unsigned long p_r45  = rotate_r45(p);
+  unsigned long my_l45 = rotate_l45(my);
+  unsigned long op_l45 = rotate_l45(op & 0x00FF7E7E7E7E7E00);
+  unsigned long p_l45  = rotate_l45(p);
+  return rotate_l45(right_pat(my_r45, op_r45, p_r45) | left_pat(my_r45, op_r45, p_r45)) |
+         rotate_r45(right_pat(my_l45, op_l45, p_l45) | left_pat(my_l45, op_l45, p_l45));
+}
+
+unsigned long right_pat(unsigned long my, unsigned long op, unsigned long p) {
+  unsigned long rev =  (p >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  return ((rev >> 1) & my) == 0 ? 0 : rev;
+}
+
+unsigned long left_pat(unsigned long my, unsigned long op, unsigned long p) {
+  unsigned long rev =  (p << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  return ((rev << 1) & my) == 0 ? 0 : rev;
+}
+
+unsigned long horizontal_pos(unsigned long my, unsigned long op, unsigned long blank) {
+  op &= 0x7E7E7E7E7E7E7E7E;
+  return right_pos(my, op, blank) | left_pos(my, op, blank);
+}
+
+unsigned long vertical_pos(unsigned long my, unsigned long op, unsigned long blank) {
+  my    = rotate_r90(my);
+  op    = rotate_r90(op & 0x00FFFFFFFFFFFF00);
+  blank = rotate_r90(blank);
+  return rotate_l90(right_pos(my, op, blank) | left_pos(my, op, blank));
+}
+
+unsigned long diagonal_pos(unsigned long my, unsigned long op, unsigned long blank) {
+  unsigned long my_r45    = rotate_r45(my);
+  unsigned long op_r45    = rotate_r45(op & 0x007E7E7E7E7E7E00);
+  unsigned long blank_r45 = rotate_r45(blank);
+  unsigned long my_l45    = rotate_l45(my);
+  unsigned long op_l45    = rotate_l45(op & 0x007E7E7E7E7E7E00);
+  unsigned long blank_l45 = rotate_l45(blank);
+  return rotate_l45(right_pos(my_r45, op_r45, blank_r45) | left_pos(my_r45, op_r45, blank_r45)) |
+         rotate_r45(right_pos(my_l45, op_l45, blank_l45) | left_pos(my_l45, op_l45, blank_l45));
+}
+
+unsigned long right_pos(unsigned long my, unsigned long op, unsigned long blank) {
+  unsigned long rev =  (my  << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  rev |= (rev << 1) & op;
+  return (rev << 1) & blank;
+}
+
+unsigned long left_pos(unsigned long my, unsigned long op, unsigned long blank) {
+  unsigned long rev =  (my  >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  rev |= (rev >> 1) & op;
+  return (rev >> 1) & blank;
+}

data/ext/reversi/bit_board_functions.h

@@ -0,0 +1,26 @@
+#ifndef BIT_BOARD_FUNCTIONS_H
+#define BIT_BOARD_FUNCTIONS_H
+
+#include "reversi.h"
+
+unsigned long XY2BB(int x, int y);
+VALUE BB2XY(unsigned long bb);
+
+unsigned long rotate_r90(unsigned long bb);
+unsigned long rotate_l90(unsigned long bb);
+unsigned long rotate_r45(unsigned long bb);
+unsigned long rotate_l45(unsigned long bb);
+
+unsigned long horizontal_pat(unsigned long my, unsigned long op, unsigned long p);
+unsigned long vertical_pat(unsigned long my, unsigned long op, unsigned long p);
+unsigned long diagonal_pat(unsigned long my, unsigned long op, unsigned long p);
+unsigned long right_pat(unsigned long my, unsigned long op, unsigned long p);
+unsigned long left_pat(unsigned long my, unsigned long op, unsigned long p);
+
+unsigned long horizontal_pos(unsigned long my, unsigned long op, unsigned long blank);
+unsigned long vertical_pos(unsigned long my, unsigned long op, unsigned long blank);
+unsigned long diagonal_pos(unsigned long my, unsigned long op, unsigned long blank);
+unsigned long right_pos(unsigned long my, unsigned long op, unsigned long blank);
+unsigned long left_pos(unsigned long my, unsigned long op, unsigned long blank);
+
+#endif

data/ext/reversi/board.c

@@ -0,0 +1,253 @@
+#include "board.h"
+
+VALUE bit_board_alloc(VALUE class) {
+  struct bit_board *ptr = ALLOC(struct bit_board);
+  return Data_Wrap_Struct(class, 0, -1, ptr);
+}
+
+/*
+ * This method is used in the `Reversi::Board.new` method.
+ */
+VALUE board_initialize(VALUE self) {
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+  ptr->black = 0x0000000000000000;
+  ptr->white = 0x0000000000000000;
+  return Qnil;
+}
+
+/*
+ * The setter method for `bit_board.black`.
+ *
+ * @param black [Fixnum, Bignum] a bitboard for black
+ */
+VALUE black_setter(VALUE self, VALUE black) {
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+  ptr->black = NUM2ULONG(black);
+  return Qnil;
+}
+
+/*
+ * The setter method for `bit_board.white`.
+ *
+ * @param black [Fixnum, Bignum] a bitboard for white
+ */
+VALUE white_setter(VALUE self, VALUE white) {
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+  ptr->white = NUM2ULONG(white);
+  return Qnil;
+}
+
+/*
+ * The getter method for `bit_board.black`.
+ *
+ * @return [Fixnum, Bignum]
+ */
+VALUE black_getter(VALUE self) {
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+  return ULONG2NUM(ptr->black);
+}
+
+/*
+ * The getter method for `bit_board.white`.
+ *
+ * @return [Fixnum, Bignum]
+ */
+VALUE white_getter(VALUE self) {
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+  return ULONG2NUM(ptr->white);
+}
+
+/*
+ * Returns a hash containing the coordinates of each color.
+ *
+ * @return [Hash{Symbol => Array<Array<Integer, Integer>>}]
+ */
+VALUE status(VALUE self) {
+  VALUE black_ary = rb_ary_new();
+  VALUE white_ary = rb_ary_new();
+  VALUE none_ary  = rb_ary_new();
+  VALUE status = rb_hash_new();
+  unsigned long black = 0, white = 0, blank = 0, p = 0;
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+
+  black = ptr->black;
+  while (black != 0) {
+    p = black & (~black + 1);
+    rb_ary_push(black_ary, BB2XY(p));
+    black ^= p;
+  }
+  rb_hash_aset(status, ID2SYM(rb_intern("black")), black_ary);
+
+  white = ptr->white;
+  while (white != 0) {
+    p = white & (~white + 1);
+    rb_ary_push(white_ary, BB2XY(p));
+    white ^= p;
+  }
+  rb_hash_aset(status, ID2SYM(rb_intern("white")), white_ary);
+
+  blank = ~(ptr->black | ptr->white);
+  while (blank != 0) {
+    p = blank & (~blank + 1);
+    rb_ary_push(none_ary, BB2XY(p));
+    blank ^= p;
+  }
+  rb_hash_aset(status, ID2SYM(rb_intern("none")), none_ary);
+
+  return status;
+}
+
+/*
+ * Returns the openness of the coordinates.
+ *
+ * @param rb_x [Integer] the column number
+ * @param rb_y [Integer] the row number
+ * @return [Integer] the openness
+ */
+VALUE openness(VALUE self, VALUE rb_x, VALUE rb_y) {
+  unsigned long p = XY2BB(FIX2INT(rb_x), FIX2INT(rb_y));
+  unsigned long blank = 0, bb = 0;
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+
+  blank = ~(ptr->black | ptr->white);
+  bb = ((p << 1) & (blank & 0xFEFEFEFEFEFEFEFE)) |
+       ((p >> 1) & (blank & 0x7F7F7F7F7F7F7F7F)) |
+       ((p << 8) & (blank & 0xFFFFFFFFFFFFFFFF)) |
+       ((p >> 8) & (blank & 0xFFFFFFFFFFFFFFFF)) |
+       ((p << 7) & (blank & 0x7F7F7F7F7F7F7F7F)) |
+       ((p >> 7) & (blank & 0xFEFEFEFEFEFEFEFE)) |
+       ((p << 9) & (blank & 0xFEFEFEFEFEFEFEFE)) |
+       ((p >> 9) & (blank & 0x7F7F7F7F7F7F7F7F));
+  bb = (bb & 0x5555555555555555) + (bb >> 1  & 0x5555555555555555);
+  bb = (bb & 0x3333333333333333) + (bb >> 2  & 0x3333333333333333);
+  bb = (bb & 0x0F0F0F0F0F0F0F0F) + (bb >> 4  & 0x0F0F0F0F0F0F0F0F);
+  bb = (bb & 0x00FF00FF00FF00FF) + (bb >> 8  & 0x00FF00FF00FF00FF);
+  bb = (bb & 0x0000FFFF0000FFFF) + (bb >> 16 & 0x0000FFFF0000FFFF);
+  return INT2FIX((int)((bb & 0x00000000FFFFFFFF) + (bb >> 32 & 0x00000000FFFFFFFF)));
+}
+
+/*
+ * Returns the color of supplied coordinates.
+ *
+ * @param rb_x [Integer] the column number
+ * @param rb_y [Integer] the row number
+ * @return [Symbol] the color or `:none`
+ */
+VALUE at(VALUE self, VALUE rb_x, VALUE rb_y) {
+  unsigned long p = XY2BB(FIX2INT(rb_x), FIX2INT(rb_y));
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+
+  if      ((p & ptr->black) != 0) { return ID2SYM(rb_intern("black")); }
+  else if ((p & ptr->white) != 0) { return ID2SYM(rb_intern("white")); }
+  else { return ID2SYM(rb_intern("none")); }
+}
+
+/*
+ * Counts the number of the supplied color's disks.
+ *
+ * @param color [Integer]
+ * @return [Integer] the sum of the counted disks
+ */
+VALUE count_disks(VALUE self, VALUE color) {
+  unsigned long bb = 0;
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+
+  switch (FIX2INT(color)) {
+    case -1: bb = ptr->black; break;
+    case  1: bb = ptr->white; break;
+    default: bb = ~(ptr->black | ptr->white); break;
+  }
+  bb = (bb & 0x5555555555555555) + (bb >> 1  & 0x5555555555555555);
+  bb = (bb & 0x3333333333333333) + (bb >> 2  & 0x3333333333333333);
+  bb = (bb & 0x0F0F0F0F0F0F0F0F) + (bb >> 4  & 0x0F0F0F0F0F0F0F0F);
+  bb = (bb & 0x00FF00FF00FF00FF) + (bb >> 8  & 0x00FF00FF00FF00FF);
+  bb = (bb & 0x0000FFFF0000FFFF) + (bb >> 16 & 0x0000FFFF0000FFFF);
+  return INT2FIX((int)((bb & 0x00000000FFFFFFFF) + (bb >> 32 & 0x00000000FFFFFFFF)));
+}
+
+/*
+ * Returns an array of the next moves.
+ *
+ * @param color [Integer]
+ * @return [Array<Array<Integer, Integer>>]
+ */
+VALUE next_moves(VALUE self, VALUE color) {
+  unsigned long my = 0, op = 0, blank = 0, p = 0, pos = 0;
+  VALUE moves = rb_ary_new();
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+
+  switch (FIX2INT(color)) {
+    case -1: my = ptr->black; op = ptr->white; break;
+    case  1: my = ptr->white; op = ptr->black; break;
+  }
+  blank = ~(my | op);
+  pos = horizontal_pos(my, op, blank) | vertical_pos(my, op, blank) | diagonal_pos(my, op, blank);
+  while (pos != 0) {
+    p = pos & (~pos + 1);
+    rb_ary_push(moves, BB2XY(p));
+    pos ^= p;
+  }
+  return moves;
+}
+
+/*
+ * Places a supplied color's disk on specified position.
+ *
+ * @param rb_x [Integer] the column number
+ * @param rb_y [Integer] the row number
+ * @param color [Integer]
+ */
+VALUE put_disk(VALUE self, VALUE rb_x, VALUE rb_y, VALUE color) {
+  unsigned long p = XY2BB(FIX2INT(rb_x), FIX2INT(rb_y));
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+
+  switch (FIX2INT(color)) {
+    case -1: ptr->black ^= p; break;
+    case  1: ptr->white ^= p; break;
+  }
+  return Qnil;
+}
+
+/*
+ * Flips the opponent's disks between a new disk and another disk of my color.
+ * The invalid move has no effect.
+ *
+ * @param rb_x [Integer] the column number
+ * @param rb_y [Integer] the row number
+ * @param color [Integer]
+ */
+VALUE flip_disks(VALUE self, VALUE rb_x, VALUE rb_y, VALUE color) {
+  unsigned long p = XY2BB(FIX2INT(rb_x), FIX2INT(rb_y));
+  unsigned long my = 0, op = 0, rev = 0;
+  struct bit_board *ptr;
+  Data_Get_Struct(self, struct bit_board, ptr);
+
+  switch(FIX2INT(color)) {
+    case -1:
+      my = ptr->black; op = ptr->white;
+      if (((ptr->black | ptr->white) & p) != 0) { rev = 0; }
+      else { rev = horizontal_pat(my, op, p) | vertical_pat(my, op, p) | diagonal_pat(my, op, p); }
+      ptr->black = (ptr->black ^ (p | rev));
+      ptr->white = (ptr->white ^ rev);
+      break;
+    case  1:
+      my = ptr->white; op = ptr->black;
+      if (((ptr->black | ptr->white) & p) != 0) { rev = 0; }
+      else { rev = horizontal_pat(my, op, p) | vertical_pat(my, op, p) | diagonal_pat(my, op, p); }
+      ptr->white = (ptr->white ^ (p | rev));
+      ptr->black = (ptr->black ^ rev);
+      break;
+  }
+  return Qnil;
+}

data/ext/reversi/board.h

@@ -0,0 +1,27 @@
+#ifndef RUBY_BOARD_H
+#define RUBY_BOARD_H
+
+#include "reversi.h"
+
+struct bit_board {
+  unsigned long black;
+  unsigned long white;
+};
+
+VALUE bit_board_alloc(VALUE class);
+VALUE board_initialize(VALUE self);
+
+VALUE black_setter(VALUE self, VALUE black);
+VALUE white_setter(VALUE self, VALUE white);
+VALUE black_getter(VALUE self);
+VALUE white_getter(VALUE self);
+
+VALUE status(VALUE self);
+VALUE openness(VALUE self, VALUE rb_x, VALUE rb_y);
+VALUE at(VALUE self, VALUE rb_x, VALUE rb_y);
+VALUE count_disks(VALUE self, VALUE color);
+VALUE next_moves(VALUE self, VALUE color);
+VALUE put_disk(VALUE self, VALUE rb_x, VALUE rb_y, VALUE color);
+VALUE flip_disks(VALUE self, VALUE rb_x, VALUE rb_y, VALUE color);
+
+#endif