reversi 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b56370e0ec9c10eab54b4fe4a6bf868c8ff37dfb
-  data.tar.gz: 9c56c3cd5a02abb11fff63a89ebc6eb6caa14a89
+  metadata.gz: b04e18b34cf5a1d99f66c71cb9d2049931aa93b7
+  data.tar.gz: c0d30414f6fcbcc2bd787da52f127667382038bb
 SHA512:
-  metadata.gz: 4d3723393465596840ba793787bf165fb051f9b49015f67f47a91f93bd5ec17ee778a2a971a8cf6f254a1c746e07f5b74304b27d186b2383510345f707fc8698
-  data.tar.gz: 5042ece105ff01a17b71a8d2f8118d7f8823dde50ff8e09c6d7421b750d2f669dcec5faa4e9ce5ea5585fdcdf1ddc9d28e0c02c500c9df16b9495b4b786468c2
+  metadata.gz: 63173220183fcd71d3eb17b36534b613df94161453fd2f94d6fbf9a14c506b6fd3e17876bd28b71b4b25751a7129cf6b0a86d0878b7ae79069f5d5112f7ab896
+  data.tar.gz: 2bf6f253e1f54af117bfea8a9a7ca89513949af1f73aab6f03c863c1acea7cf1da392f76ef5f123119429f2af1b3f849ba2aad8ab779025a8f81dcbc2cf08741

data/ext/reversi/bit_board_functions.c

@@ -12,85 +12,25 @@ uint64_t XY2BB(int x, int y) {
  */
 VALUE BB2XY(uint64_t 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;
-  }
+  int x = 8 - ( (int)log2((double)bb) % 8 );
+  int y = 8 - ( (int)log2((double)bb) / 8 );
+  rb_ary_push(xy, INT2FIX(x));
+  rb_ary_push(xy, INT2FIX(y));
   return xy;
 }
 
 /*
  * Rotate a bitboard by 90 degrees to the right.
+ * 
+ * For example,
+ * 1 1 1 1 1 1 1 1    0 0 0 0 0 0 0 1
+ * 0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 1
+ * 0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 1
+ * 0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 1
+ * 0 0 0 0 0 0 0 0 -> 0 0 0 0 0 0 0 1
+ * 0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 1
+ * 0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 1
+ * 0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 1
  */
 uint64_t rotate_r90(uint64_t bb) {
   bb = ((bb <<  8) & 0xAA00AA00AA00AA00) |
@@ -110,6 +50,16 @@ uint64_t rotate_r90(uint64_t bb) {
 
 /*
  * Rotate a bitboard by 90 degrees to the left.
+ * 
+ * For example,
+ * 1 1 1 1 1 1 1 1    1 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 0    1 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 0    1 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 0    1 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 0 -> 1 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 0    1 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 0    1 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 0    1 0 0 0 0 0 0 0
  */
 uint64_t rotate_l90(uint64_t bb) {
   bb = ((bb <<  1) & 0xAA00AA00AA00AA00) |
@@ -129,6 +79,16 @@ uint64_t rotate_l90(uint64_t bb) {
 
 /*
  * Rotate a bitboard by 45 degrees to the right.
+ * 
+ * For example,
+ * 0 0 0 0 0 0 0 1    1 1 1 1 1 1 1 1
+ * 0 0 0 0 0 0 1 0    0 0 0 0 0 0 0 0
+ * 0 0 0 0 0 1 0 0    0 0 0 0 0 0 0 0
+ * 0 0 0 0 1 0 0 0    0 0 0 0 0 0 0 0
+ * 0 0 0 1 0 0 0 0 -> 0 0 0 0 0 0 0 0
+ * 0 0 1 0 0 0 0 0    0 0 0 0 0 0 0 0
+ * 0 1 0 0 0 0 0 0    0 0 0 0 0 0 0 0
+ * 1 0 0 0 0 0 0 0    0 0 0 0 0 0 0 0
  */
 uint64_t rotate_r45(uint64_t bb) {
   bb = (bb & 0x0101010101010101) |
@@ -144,6 +104,16 @@ uint64_t rotate_r45(uint64_t bb) {
 
 /*
  * Rotate a bitboard by 45 degrees to the left.
+ * 
+ * For example,
+ * 1 0 0 0 0 0 0 0    0 0 0 0 0 0 0 0
+ * 0 1 0 0 0 0 0 0    0 0 0 0 0 0 0 0
+ * 0 0 1 0 0 0 0 0    0 0 0 0 0 0 0 0
+ * 0 0 0 1 0 0 0 0    0 0 0 0 0 0 0 0
+ * 0 0 0 0 1 0 0 0 -> 0 0 0 0 0 0 0 0
+ * 0 0 0 0 0 1 0 0    0 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 1 0    0 0 0 0 0 0 0 0
+ * 0 0 0 0 0 0 0 1    1 1 1 1 1 1 1 1
  */
 uint64_t rotate_l45(uint64_t bb) {
   bb = (bb & 0x0101010101010101) |
@@ -157,11 +127,45 @@ uint64_t rotate_l45(uint64_t bb) {
   return bb;
 }
 
+/*
+ * 'p' is a position of player's move, 'XY2BB(FIX2INT(rb_x), FIX2INT(rb_y))'.
+ * 'my' is a bitboard of my disks, and 'op' is a bitboard of  opponent's disks.
+ * horizontal_pat, vertical_pat and diagonal_pat method
+ * are used in Reversi::Board#flip_disks method to get the positions
+ * of the opponent's disks between a new disk and another disk of my color.
+ * 
+ * This method returns a bitboard of flippable oppenent's disks 
+ * in the horizontal direction.
+ *
+ * A mask for the horizontal direction is '0x7E7E7E7E7E7E7E7E'.
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ */
 uint64_t horizontal_pat(uint64_t my, uint64_t op, uint64_t p) {
   op &= 0x7E7E7E7E7E7E7E7E;
   return right_pat(my, op, p) | left_pat(my, op, p);
 }
 
+/*
+ * This method returns a bitboard of flippable oppenent's disks 
+ * in the vertical direction.
+ *
+ * A mask for the vertical direction is '0x00FFFFFFFFFFFF00'.
+ * 0 0 0 0 0 0 0 0
+ * 1 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1 1
+ * 0 0 0 0 0 0 0 0
+ */
 uint64_t vertical_pat(uint64_t my, uint64_t op, uint64_t p) {
   my = rotate_r90(my);
   op = rotate_r90(op & 0x00FFFFFFFFFFFF00);
@@ -169,17 +173,35 @@ uint64_t vertical_pat(uint64_t my, uint64_t op, uint64_t p) {
   return rotate_l90(right_pat(my, op, p) | left_pat(my, op, p));
 }
 
+/*
+ * This method returns a bitboard of flippable oppenent's disks 
+ * in the diagonal direction.
+ *
+ * a masks for the diagonal direction is '0x007E7E7E7E7E7E00'.
+ * 0 0 0 0 0 0 0 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 1 1 1 1 1 1 0
+ * 0 0 0 0 0 0 0 0
+ */
 uint64_t diagonal_pat(uint64_t my, uint64_t op, uint64_t p) {
   uint64_t my_r45 = rotate_r45(my);
   uint64_t op_r45 = rotate_r45(op & 0x007E7E7E7E7E7E00);
   uint64_t p_r45  = rotate_r45(p);
   uint64_t my_l45 = rotate_l45(my);
-  uint64_t op_l45 = rotate_l45(op & 0x00FF7E7E7E7E7E00);
+  uint64_t op_l45 = rotate_l45(op & 0x007E7E7E7E7E7E00);
   uint64_t 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));
 }
 
+/*
+ * This method returns a bitboard of flippable oppenent's disks 
+ * in the right direction.
+ */
 uint64_t right_pat(uint64_t my, uint64_t op, uint64_t p) {
   uint64_t rev =  (p >> 1) & op;
   rev |= (rev >> 1) & op;
@@ -190,6 +212,10 @@ uint64_t right_pat(uint64_t my, uint64_t op, uint64_t p) {
   return ((rev >> 1) & my) == 0 ? 0 : rev;
 }
 
+/*
+ * This method returns a bitboard of flippable oppenent's disks 
+ * in the left direction.
+ */
 uint64_t left_pat(uint64_t my, uint64_t op, uint64_t p) {
   uint64_t rev =  (p << 1) & op;
   rev |= (rev << 1) & op;
@@ -200,11 +226,24 @@ uint64_t left_pat(uint64_t my, uint64_t op, uint64_t p) {
   return ((rev << 1) & my) == 0 ? 0 : rev;
 }
 
+/*
+ * 'p' is a position of player's move, 'XY2BB(FIX2INT(rb_x), FIX2INT(rb_y))'.
+ * 'my' is a bitboard of my disks, and 'op' is a bitboard of  opponent's disks.
+ * horizontal_pos, vertical_pos and diagonal_pos method
+ * are used in Reversi::Board#next_moves method to get positions of the next move.
+ * 
+ * This method returns a bitboard of nextmove's positions
+ * in the horizontal direction.
+ */
 uint64_t horizontal_pos(uint64_t my, uint64_t op, uint64_t blank) {
   op &= 0x7E7E7E7E7E7E7E7E;
   return right_pos(my, op, blank) | left_pos(my, op, blank);
 }
 
+/*
+ * This method returns a bitboard of nextmove's positions
+ * in the vertical direction.
+ */
 uint64_t vertical_pos(uint64_t my, uint64_t op, uint64_t blank) {
   my    = rotate_r90(my);
   op    = rotate_r90(op & 0x00FFFFFFFFFFFF00);
@@ -212,6 +251,10 @@ uint64_t vertical_pos(uint64_t my, uint64_t op, uint64_t blank) {
   return rotate_l90(right_pos(my, op, blank) | left_pos(my, op, blank));
 }
 
+/*
+ * This method returns a bitboard of nextmove's positions
+ * in the diagonal direction.
+ */
 uint64_t diagonal_pos(uint64_t my, uint64_t op, uint64_t blank) {
   uint64_t my_r45    = rotate_r45(my);
   uint64_t op_r45    = rotate_r45(op & 0x007E7E7E7E7E7E00);
@@ -223,6 +266,10 @@ uint64_t diagonal_pos(uint64_t my, uint64_t op, uint64_t blank) {
          rotate_r45(right_pos(my_l45, op_l45, blank_l45) | left_pos(my_l45, op_l45, blank_l45));
 }
 
+/*
+ * This method returns a bitboard of nextmove's positions
+ * in the right direction.
+ */
 uint64_t right_pos(uint64_t my, uint64_t op, uint64_t blank) {
   uint64_t rev =  (my  << 1) & op;
   rev |= (rev << 1) & op;
@@ -233,6 +280,10 @@ uint64_t right_pos(uint64_t my, uint64_t op, uint64_t blank) {
   return (rev << 1) & blank;
 }
 
+/*
+ * This method returns a bitboard of nextmove's positions
+ * in the left direction.
+ */
 uint64_t left_pos(uint64_t my, uint64_t op, uint64_t blank) {
   uint64_t rev =  (my  >> 1) & op;
   rev |= (rev >> 1) & op;

data/ext/reversi/board.c

@@ -21,7 +21,7 @@ VALUE board_initialize(VALUE self) {
  *
  * @param black [Fixnum, Bignum] a bitboard for black
  */
-VALUE black_setter(VALUE self, VALUE black) {
+VALUE set_black(VALUE self, VALUE black) {
   struct bit_board *ptr;
   Data_Get_Struct(self, struct bit_board, ptr);
   ptr->black = NUM2ULL(black);
@@ -33,7 +33,7 @@ VALUE black_setter(VALUE self, VALUE black) {
  *
  * @param black [Fixnum, Bignum] a bitboard for white
  */
-VALUE white_setter(VALUE self, VALUE white) {
+VALUE set_white(VALUE self, VALUE white) {
   struct bit_board *ptr;
   Data_Get_Struct(self, struct bit_board, ptr);
   ptr->white = NUM2ULL(white);
@@ -45,7 +45,7 @@ VALUE white_setter(VALUE self, VALUE white) {
  *
  * @return [Fixnum, Bignum]
  */
-VALUE black_getter(VALUE self) {
+VALUE get_black(VALUE self) {
   struct bit_board *ptr;
   Data_Get_Struct(self, struct bit_board, ptr);
   return ULL2NUM(ptr->black);
@@ -56,7 +56,7 @@ VALUE black_getter(VALUE self) {
  *
  * @return [Fixnum, Bignum]
  */
-VALUE white_getter(VALUE self) {
+VALUE get_white(VALUE self) {
   struct bit_board *ptr;
   Data_Get_Struct(self, struct bit_board, ptr);
   return ULL2NUM(ptr->white);

data/ext/reversi/board.h

@@ -11,10 +11,10 @@ struct bit_board {
 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 set_black(VALUE self, VALUE black);
+VALUE set_white(VALUE self, VALUE white);
+VALUE get_black(VALUE self);
+VALUE get_white(VALUE self);
 
 VALUE status(VALUE self);
 VALUE openness(VALUE self, VALUE rb_x, VALUE rb_y);

data/ext/reversi/reversi.c

@@ -7,10 +7,10 @@ void Init_reversi(void) {
   rb_define_alloc_func(reversi_board, bit_board_alloc);
 
   /* These private methods are used in the board.rb file. */
-  rb_define_private_method(reversi_board, "black_setter", black_setter, 1);
-  rb_define_private_method(reversi_board, "white_setter", white_setter, 1);
-  rb_define_private_method(reversi_board, "black_getter", black_getter, 0);
-  rb_define_private_method(reversi_board, "white_getter", white_getter, 0);
+  rb_define_private_method(reversi_board, "set_black", set_black, 1);
+  rb_define_private_method(reversi_board, "set_white", set_white, 1);
+  rb_define_private_method(reversi_board, "get_black", get_black, 0);
+  rb_define_private_method(reversi_board, "get_white", get_white, 0);
 
   /* This method is used in the `Reversi::Board.new` method. */
   rb_define_private_method(reversi_board, "board_initialize", board_initialize, 0);

data/ext/reversi/reversi.h

@@ -6,6 +6,7 @@
 #include <memory.h>
 #include <stdio.h>
 #include <stdint.h>
+#include <math.h>
 
 #include "board.h"
 #include "bit_board_functions.h"

data/lib/reversi/board.rb

@@ -54,8 +54,8 @@ module Reversi
       "   #{"+---"*8}+\n" <<
       (0..63).map do |i|
         case 1
-        when black_getter[63 - i] then "\e[#{@options[:disk_color_b]}m#{@options[:disk_b]}\e[0m"
-        when white_getter[63 - i] then "\e[#{@options[:disk_color_w]}m#{@options[:disk_w]}\e[0m"
+        when get_black[63 - i] then "\e[#{@options[:disk_color_b]}m#{@options[:disk_b]}\e[0m"
+        when get_white[63 - i] then "\e[#{@options[:disk_color_w]}m#{@options[:disk_w]}\e[0m"
         else " "
         end
       end
@@ -69,7 +69,7 @@ module Reversi
     # Pushes an array of the game board onto a stack.
     # The stack size limit is 3(default).
     def push_stack
-      bb = {:black => black_getter,:white => white_getter}
+      bb = {:black => get_black,:white => get_white}
       @stack.push(Marshal.load(Marshal.dump(bb)))
       @stack.shift if @stack.size > @options[:stack_limit]
     end
@@ -78,8 +78,8 @@ module Reversi
     # and that is stored in the instance variable.(`@bit_board`)
     def undo!
       bb = @stack.pop
-      black_setter(bb[:black])
-      white_setter(bb[:white])
+      set_black(bb[:black])
+      set_white(bb[:white])
     end
   end
 end

data/lib/reversi/configuration.rb

@@ -27,20 +27,24 @@ module Reversi
 
     attr_accessor *OPTIONS_KEYS
 
+    # This method is used for setting configuration options.
     def configure
       yield self
     end
 
+    # Create a hash of options.
     def options
       Hash[*OPTIONS_KEYS.map{|key| [key, send(key)]}.flatten]
     end
 
+    # Reset all options to their default values.
     def reset
       DEFAULTS.each do |option, default|
         self.send("#{option}=".to_sym, default)
       end
     end
 
+    # Set default value for the option that is still not set.
     def set_defaults
       DEFAULTS.each do |option, default|
         default.class == String ?

data/lib/reversi/version.rb

@@ -1,3 +1,3 @@
 module Reversi
-  VERSION = "2.0.3"
+  VERSION = "2.0.4"
 end

data/spec/game_spec.rb

@@ -101,8 +101,8 @@ describe Reversi::Game do
       :white =>0x7F60_513B_274B_0400
     }
     it do
-      expect(game.board.send(:black_getter)).to eq ans[:black]
-      expect(game.board.send(:white_getter)).to eq ans[:white]
+      expect(game.board.send(:get_black)).to eq ans[:black]
+      expect(game.board.send(:get_white)).to eq ans[:white]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reversi
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - seinosuke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-13 00:00:00.000000000 Z
+date: 2015-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler