reversi 1.0.2 → 2.0.0

data/ext/reversi/reversi.c

@@ -1,396 +1,26 @@
 #include "reversi.h"
 
-struct stack{
-  int stack_columns[10][10];
-  struct stack *next;
-};
-
-struct stack *head = NULL;
-
-struct board {
-  int columns[10][10];
-};
-
 void Init_reversi(void) {
   VALUE reversi = rb_define_module("Reversi");
   VALUE reversi_board = rb_define_class_under(reversi, "Board", rb_cObject);
 
-  rb_define_alloc_func(reversi_board, board_alloc);
-
-  /* The getter method for a Reversi::Board object. */
-  rb_define_method(reversi_board, "columns", board_columns_getter, 0);
-  rb_define_method(reversi_board, "stack", board_stack_getter, 0);
-
-  /* The instance method for a Reversi::Board object. */
-  rb_define_method(reversi_board, "undo!", board_undo, 0);
+  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, "board_initialize", board_initialize, 0);
-  rb_define_private_method(reversi_board, "board_push_stack", board_push_stack, 1);
-  rb_define_private_method(reversi_board, "board_status", board_status, 0);
-  rb_define_private_method(reversi_board, "board_openness", board_openness, 2);
-  rb_define_private_method(reversi_board, "board_at", board_at, 2);
-  rb_define_private_method(reversi_board, "board_count_disks", board_count_disks, 1);
-  rb_define_private_method(reversi_board, "board_next_moves", board_next_moves, 1);
-  rb_define_private_method(reversi_board, "board_put_disk", board_put_disk, 3);
-  rb_define_private_method(reversi_board, "board_flip_disks", board_flip_disks, 3);
-}
-
-static VALUE board_alloc(VALUE class) {
-  struct board *ptr = ALLOC(struct board);
-  return Data_Wrap_Struct(class, 0, -1, ptr);
-}
-
-static VALUE board_initialize(VALUE self) {
-  int x, y;
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  reset_stack();
-  head = NULL;
-
-  for(x = 0; x < 10; x++) {
-    for(y = 0; y < 10; y++) {
-      if(x == 0 || x == 9) ptr->columns[x][y] = 2;
-      else if(y == 0 || y == 9) ptr->columns[x][y] = 2;
-      else ptr->columns[x][y] = 0;
-    }
-  }
-  return Qnil;
-}
-
-/*
- * The getter method for the instance variable `columns`.
- *
- * @return [Array]
- */
-static VALUE board_columns_getter(VALUE self) {
-  VALUE column = rb_ary_new();
-  VALUE columns = rb_ary_new();
-  int x, y;
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  for(x = 0; x < 10; x++) {
-    column = rb_ary_new();
-    for(y = 0; y < 10; y++) rb_ary_push(column, INT2FIX(ptr->columns[x][y]));
-    rb_ary_push(columns, column);
-  }
-  return columns;
-}
-
-/*
- * The getter method for the instance variable `stack`.
- *
- * @return [Array]
- */
-static VALUE board_stack_getter(VALUE self) {
-  VALUE stack = rb_ary_new();
-  VALUE column = rb_ary_new();
-  VALUE columns = rb_ary_new();
-  int x, y;
-  struct stack *sp;
-
-  for(sp = head; sp != NULL; sp = sp->next) {
-    columns = rb_ary_new();
-    for(x = 0; x < 10; x++) {
-      column = rb_ary_new();
-      for(y = 0; y < 10; y++) rb_ary_push(column, INT2FIX(sp->stack_columns[x][y]));
-      rb_ary_push(columns, column);
-    }
-    rb_ary_push(stack, columns);
-  }
-  return stack;
-}
-
-/*
- * Pops an array of the game board off of the stack,
- * and that is stored in the instance variable `columns`.
- */
-static VALUE board_undo(VALUE self) {
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-  pop_stack(ptr->columns);
-  return Qnil;
-}
-
-/*
- * Pushes an array of the game board onto a stack.
- *
- * @param limit [Integer] An upper limit size of the stack.
- */
-static VALUE board_push_stack(VALUE self, VALUE limit) {
-  push_stack(self, FIX2INT(limit));
-  return Qnil;
-}
-
-/*
- * Returns an array containing the coordinates of each color.
- * The arrays are stored `black`, `while`, and `none` in that order.
- *
- * @return [Array]
- */
-static VALUE board_status(VALUE self) {
-  VALUE black = rb_ary_new();
-  VALUE white = rb_ary_new();
-  VALUE none = rb_ary_new();
-  VALUE position = rb_ary_new();
-  VALUE status = rb_ary_new();
-  int x, y;
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  for(x = 0; x < 10; x++) {
-    for(y = 0; y < 10; y++) {
-      switch (ptr->columns[x][y]) {
-        case -1:
-          rb_ary_push(position, INT2FIX(x));
-          rb_ary_push(position, INT2FIX(y));
-          rb_ary_push(black, position);
-          position = rb_ary_new(); break;
-        case 1:
-          rb_ary_push(position, INT2FIX(x));
-          rb_ary_push(position, INT2FIX(y));
-          rb_ary_push(white, position);
-          position = rb_ary_new(); break;
-        case 0:
-          rb_ary_push(position, INT2FIX(x));
-          rb_ary_push(position, INT2FIX(y));
-          rb_ary_push(none, position);
-          position = rb_ary_new(); break;
-      }
-    }
-  }
-
-  rb_ary_push(status, black);
-  rb_ary_push(status, white);
-  rb_ary_push(status, none);
-  return status;
-}
-
-/*
- * Returns the openness of the coordinates.
- *
- * @param x [Integer] the column number
- * @param y [Integer] the row number
- * @return [Integer] the openness
- */
-static VALUE board_openness(VALUE self, VALUE x, VALUE y) {
-  int dx, dy, sum = 0;
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  for(dx = -1; dx < 2; dx++){
-    for(dy = -1; dy < 2; dy++){
-      if (dx == 0 && dy == 0) continue;
-      if (ptr->columns[FIX2INT(x) + dx][FIX2INT(y) + dy] == 0) sum += 1;
-    }
-  }
-  return INT2FIX(sum);
-}
-
-/*
- * Returns the disk color of supplied coordinates.
- *
- * @param x [Integer] the column number
- * @param y [Integer] the row number
- * @return [Integer] `black`: -1, `white`: 1, `none`: 0
- */
-static VALUE board_at(VALUE self, VALUE x, VALUE y) {
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-  return INT2FIX(ptr->columns[FIX2INT(x)][FIX2INT(y)]);
-}
-
-/*
- * Counts the number of the supplied color's disks.
- *
- * @param color [Integer] `black`: -1, `white`: 1, `none`: 0
- * @return [Integer] the sum of the counted disks
- */
-static VALUE board_count_disks(VALUE self, VALUE color) {
-  int x, y, count = 0;
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
+  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);
 
-  for(x = 1; x < 9; x++){
-    for(y = 1; y < 9; y++){
-      if (ptr->columns[x][y] == FIX2INT(color)) count += 1;
-    }
-  }
-  return INT2FIX(count);
-}
-
-/*
- * Returns an array of the next moves.
- *
- * @param color [Integer] `black`: -1, `white`: 1, `none`: 0
- * @return [Array] the next moves
- */
-static VALUE board_next_moves(VALUE self, VALUE color) {
-  int x, y;
-  VALUE move = rb_ary_new();
-  VALUE moves = rb_ary_new();
-
-  for(x = 1; x < 9; x++){
-    for(y = 1; y < 9; y++){
-      if (can_put(self, x, y, FIX2INT(color)) == 1){
-        move = rb_ary_new();
-        rb_ary_push(move, INT2FIX(x));
-        rb_ary_push(move, INT2FIX(y));
-        rb_ary_push(moves, move);
-      }
-    }
-  }
-  return moves;
-}
-
-/*
- * Places a supplied color's disk on specified position.
- *
- * @param x [Integer] the column number
- * @param y [Integer] the row number
- * @param color [Integer] `black`: -1, `white`: 1, `none`: 0
- */
-static VALUE board_put_disk(VALUE self, VALUE x, VALUE y, VALUE color) {
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  ptr->columns[FIX2INT(x)][FIX2INT(y)] = FIX2INT(color);
-  return Qnil;
-}
-
-/*
- * Flips the opponent's disks between a new disk and another disk of my color.
- * The invalid move has no effect.
- *
- * @param x [Integer] the column number
- * @param y [Integer] the row number
- * @param color [Integer] `black`: -1, `white`: 1, `none`: 0
- */
-static VALUE board_flip_disks(VALUE self, VALUE x, VALUE y, VALUE color) {
-  int dx, dy;
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-  x = FIX2INT(x);
-  y = FIX2INT(y);
-  color = FIX2INT(color);
-
-  for(dx = -1; dx < 2; dx++){
-    for(dy = -1; dy < 2; dy++){
-      if (dx == 0 && dy == 0) continue;
-      if (ptr->columns[x + dx][y + dy] == (signed)(-color) &&
-         can_flip(self, x, y, dx, dy, color) == 1)
-        flip_disk(self, x, y, dx, dy, color);
-    }
-  }
-  return Qnil;
-}
-
-/*
- * Flips the opponent's disks on one of these straight lines
- * between a new disk and another disk of my color.
- */
-void flip_disk(VALUE self, int x, int y, int dx, int dy, int color){
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  x += dx; y += dy;
-  if (ptr->columns[x][y] == 2 ||
-      ptr->columns[x][y] == 0 ||
-      ptr->columns[x][y] == color) return;
-  ptr->columns[x][y] = color;
-  flip_disk(self, x, y, dx, dy, color);
-  return;
-}
-
-/*
- * Whether or not a player can place a new disk on specified position.
- * Returns `1` if the move is valid.
- */
-int can_put(VALUE self, int x, int y, int color){
-  int dx, dy;
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  if (ptr->columns[x][y] != 0) return 0;
-
-  for(dx = -1; dx < 2; dx++){
-    for(dy = -1; dy < 2; dy++){
-      if (dx == 0 && dy == 0) continue;
-      if (ptr->columns[x + dx][y + dy] == -color){
-        if (can_flip(self, x, y, dx, dy, color) == 1) return 1;
-      }
-    }
-  }
-  return 0;
-}
-
-/*
- * Whether or not a player can flip the opponent's disks.
- */
-int can_flip(VALUE self, int x, int y, int dx, int dy, int color){
-  struct board *ptr;
-  Data_Get_Struct(self, struct board, ptr);
-
-  while(1){
-    x += dx; y += dy;
-    if (ptr->columns[x][y] == color) return 1;
-    if (ptr->columns[x][y] == 2 || ptr->columns[x][y] == 0) break;
-  }
-  return 0;
-}
-
-void push_stack(VALUE self, int limit){
-  int size = 0;
-  struct board *bp;
-  struct stack *sp;
-  Data_Get_Struct(self, struct board, bp);
-
-  for(sp = head; sp != NULL; sp = sp->next);
-  sp = (struct stack *)malloc(sizeof(struct stack));
-
-  memcpy(sp->stack_columns, bp->columns, sizeof(bp->columns));
-  sp->next = head;
-  head = sp;
-
-  size = stack_size();
-  if (size > limit) delete_old();
-  return;
-}
-
-void pop_stack(int ary[10][10]){
-  struct stack *p;
-  memcpy(ary, head->stack_columns, sizeof(head->stack_columns));
-  p = head;
-  head = p->next;
-  free(p);
-  return;
-}
-
-int stack_size(void){
-  int count = 0;
-  struct stack *p;
-  for(p = head; p != NULL; p = p->next) count++;
-  return count;
-}
-
-void delete_old(void){
-  struct stack *p;
-  for(p = head; p->next->next != NULL; p = p->next);
-  p->next = NULL;
-  free(p->next);
-  return;
-}
-
-void reset_stack(void){
-  struct stack *p = head;
-  struct stack *tmp;
+  /* This method is used in the `Reversi::Board.new` method. */
+  rb_define_private_method(reversi_board, "board_initialize", board_initialize, 0);
 
-  while(p != NULL){
-    tmp = p->next;
-    free(p);
-    p = tmp; 
-  }
-  return;
+  /* The instance method for a Reversi::Board object. */
+  rb_define_method(reversi_board, "status", status, 0);
+  rb_define_method(reversi_board, "openness", openness, 2);
+  rb_define_method(reversi_board, "at", at, 2);
+  rb_define_method(reversi_board, "count_disks", count_disks, 1);
+  rb_define_method(reversi_board, "next_moves", next_moves, 1);
+  rb_define_method(reversi_board, "put_disk", put_disk, 3);
+  rb_define_method(reversi_board, "flip_disks", flip_disks, 3);
 }

data/ext/reversi/reversi.h

@@ -1,29 +1,14 @@
+#ifndef RUBY_REVERSI_H
+#define RUBY_REVERSI_H
+
 #include <ruby.h>
 #include <stdlib.h>
 #include <memory.h>
+#include <stdio.h>
 
-void Init_board(void);
-
-static VALUE board_alloc(VALUE class);
-static VALUE board_initialize(VALUE self);
-static VALUE board_columns_getter(VALUE self);
-static VALUE board_stack_getter(VALUE self);
-static VALUE board_push_stack(VALUE self, VALUE limit);
-static VALUE board_undo(VALUE self);
-static VALUE board_status(VALUE self);
-static VALUE board_openness(VALUE self, VALUE x, VALUE y);
-static VALUE board_at(VALUE self, VALUE x, VALUE y);
-static VALUE board_count_disks(VALUE self, VALUE color);
-static VALUE board_next_moves(VALUE self, VALUE color);
-static VALUE board_put_disk(VALUE self, VALUE x, VALUE y, VALUE color);
-static VALUE board_flip_disks(VALUE self, VALUE x, VALUE y, VALUE color);
+#include "board.h"
+#include "bit_board_functions.h"
 
-void flip_disk(VALUE self, int x, int y, int dx, int dy, int color);
-int can_put(VALUE self, int x, int y, int color);
-int can_flip(VALUE self, int x, int y, int dx, int dy, int color);
+void Init_reversi(void);
 
-void push_stack(VALUE self, int limit);
-void pop_stack(int ary[10][10]);
-int stack_size(void);
-void delete_old(void);
-void reset_stack(void);
+#endif

data/lib/reversi/board.rb

@@ -1,10 +1,9 @@
 module Reversi
   class Board
-    attr_reader :options
+    attr_reader :options, :stack
 
     DISK = {
       :none  =>  0,
-      :wall  =>  2,
       :black => -1,
       :white =>  1
     }.freeze
@@ -28,14 +27,17 @@ module Reversi
     # @return [Reversi::Board]
     def initialize(options = {})
       @options = options
+      @stack = []
+      board_initialize
+
       [:disk_color_b, :disk_color_w].each do |color|
         if @options[color].is_a?(Symbol) || @options[color].is_a?(String)
           @options[color] = DISK_COLOR[@options[color].to_sym].to_i
         end
       end
-      board_initialize
+
       @options[:initial_position].each do |color, positions|
-        positions.each{ |position| put_disk(*position, color) }
+        positions.each{ |position| put_disk(*position, DISK[color]) }
       end
     end
 
@@ -45,16 +47,16 @@ module Reversi
     def to_s
       "     #{[*'a'..'h'].join("   ")}\n" <<
       "   #{"+---"*8}+\n" <<
-      columns[1][1..-2].zip(*columns[2..8].map{ |col| col[1..-2] })
-      .map{ |row| row.map do |e|
-        case e
-        when  0 then " "
-        when -1 then "\e[#{@options[:disk_color_b]}m#{@options[:disk_b]}\e[0m"
-        when  1 then "\e[#{@options[:disk_color_w]}m#{@options[:disk_w]}\e[0m"
+      (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"
+        else " "
         end
       end
-      .map{ |e| "| #{e} |" }.join }.map{ |e| e.gsub(/\|\|/, "|") }
-      .tap{ |rows| break [*0..7].map{ |i| " #{i+1} " << rows[i] } }
+      .map{ |e| "| #{e} |" }.each_slice(8).map(&:join)
+      .map{ |line| line.gsub(/\|\|/, "|") }
+      .tap{ |lines| break (0..7).map{ |i| " #{i+1} #{lines[i]}" } }
       .join("\n   #{"+---"*8}+\n") <<
       "\n   #{"+---"*8}+\n"
     end
@@ -62,72 +64,17 @@ module Reversi
     # Pushes an array of the game board onto a stack.
     # The stack size limit is 3(default).
     def push_stack
-      board_push_stack(@options[:stack_limit])
-    end
-
-    # Returns a hash containing the coordinates of each color.
-    #
-    # @return [Hash{Symbol => Array<Symbol, Integer>}]
-    def status
-      ary = board_status
-      {:black => ary[0], :white => ary[1], :none => ary[2]}
-    end
-
-    # Returns the openness of the coordinates.
-    #
-    # @param x [Symbol, Integer] the column number
-    # @param y [Integer] the row number
-    # @return [Integer] the openness
-    def openness(x, y)
-      x = [*:a..:h].index(x) + 1 if x.is_a? Symbol
-      board_openness(x, y)
+      bb = {:black => black_getter,:white => white_getter}
+      @stack.push(Marshal.load(Marshal.dump(bb)))
+      @stack.shift if @stack.size > @options[:stack_limit]
     end
 
-    # Returns the color of supplied coordinates.
-    #
-    # @param x [Symbol, Integer] the column number
-    # @param y [Integer] the row number
-    # @return [Symbol] the color or `:none`
-    def at(x, y)
-      x = [*:a..:h].index(x) + 1 if x.is_a? Symbol
-      DISK.key(board_at(x, y))
-    end
-
-    # Counts the number of the supplied color's disks.
-    #
-    # @param color [Symbol]
-    # @return [Integer] the sum of the counted disks
-    def count_disks(color)
-      board_count_disks(DISK[color])
-    end
-
-    # Returns an array of the next moves.
-    #
-    # @param color [Symbol]
-    # @return [Array<Array<Symbol, Integer>>]
-    def next_moves(color)
-      board_next_moves(DISK[color])
-    end
-
-    # Places a supplied color's disk on specified position.
-    #
-    # @param x [Symbol, Integer] the column number
-    # @param y [Integer] the row number
-    # @param color [Symbol]
-    def put_disk(x, y, color)
-      x = [*:a..:h].index(x) + 1 if x.is_a? Symbol
-      board_put_disk(x, y, DISK[color])
-    end
-
-    # Flips the opponent's disks between a new disk and another disk of my color.
-    # The invalid move has no effect.
-    #
-    # @param x [Symbol, Integer] the column number
-    # @param y [Integer] the row number
-    # @param color [Symbol]
-    def flip_disks(x, y, color)
-      x = [*:a..:h].index(x) + 1 if x.is_a? Symbol
-      board_flip_disks(x, y, DISK[color])
+    # Pops a hash of the game board off of the stack,
+    # and that is stored in the instance variable.(`@bit_board`)
+    def undo!
+      bb = @stack.pop
+      black_setter(bb[:black])
+      white_setter(bb[:white])
     end
   end
 end

data/lib/reversi/game.rb

@@ -25,8 +25,8 @@ module Reversi
       @board = Board.new(@options)
       @player_class_b = @player_b
       @player_class_w = @player_w
-      @player_b = @player_class_b.new(:black, @board)
-      @player_w = @player_class_w.new(:white, @board)
+      @player_b = @player_class_b.new(Reversi::Board::DISK[:black], @board)
+      @player_w = @player_class_w.new(Reversi::Board::DISK[:white], @board)
     end
 
     # Load the configuration.
@@ -53,11 +53,13 @@ module Reversi
       loop do
         break if game_over?
         @status = @board.status
-        @player_b.move(@board); check_move(:black)
+        @player_b.move(@board)
+        check_move(:black)
         show_board if mode[:progress]
 
         @status = @board.status
-        @player_w.move(@board); check_move(:white)
+        @player_w.move(@board)
+        check_move(:white)
         show_board if mode[:progress]
       end
       puts @board.to_s if mode[:progress] || mode[:vs_human]
@@ -73,16 +75,16 @@ module Reversi
 
     # Checks a move to make sure it is valid.
     def check_move(color)
-      blank_diff = @status[:none].size - @board.count_disks(:none)
+      blank_diff = @status[:none].size - @board.count_disks(Reversi::Board::DISK[:none])
 
       case blank_diff
       when 1
-        if (@board.count_disks(color) - @status[color].size) < 2
+        if (@board.count_disks(Reversi::Board::DISK[color]) - @status[color].size) < 2
           raise MoveError, "A player must flip at least one or more opponent's disks."
         end
       when 0
-        unless (@board.count_disks(:black) - @status[:black].size) == 0 &&
-               (@board.count_disks(:white) - @status[:white].size) == 0
+        unless (@board.count_disks(Reversi::Board::DISK[:black]) - @status[:black].size) == 0 &&
+               (@board.count_disks(Reversi::Board::DISK[:white]) - @status[:white].size) == 0
           raise MoveError, "When a player can't make a valid move, you must not place a new disk."
         end
       else

data/lib/reversi/player/alpha_beta_ai.rb

@@ -21,7 +21,7 @@ module Reversi::Player
     end
 
     def move(board)
-      moves = next_moves.sort_by{ |v| v[:openness] }.map{ |v| v[:move] }
+      moves = next_moves
       return if moves.empty?
       alpha = -N; beta = N
       next_move = moves.map do |move|
@@ -32,7 +32,7 @@ module Reversi::Player
 
     def evaluate(move, board, alpha, beta, depth, color)
       put_disk(*move, color)
-      moves = next_moves(!color).sort_by{ |v| v[:openness] }.map{ |v| v[:move] }
+      moves = next_moves(!color)
 
       if depth == 1
         status[:mine].inject(0){ |sum, xy| sum + @evaluation_value[xy] }