reversi 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c602bf3c1c6a4dc238b2a168a769f4b46a5727f
-  data.tar.gz: 88313f627c8fef5882dbfa5829c225ff0a1e3e0b
+  metadata.gz: f21066f809daeaccbfdfbc19f61dc5ac79b0dbca
+  data.tar.gz: dca98c6b7c7f64ae612e35dd3a218a9993b35434
 SHA512:
-  metadata.gz: 409dcbf84198f1f7e0bff93e3314a5cf6b6126381eca11fff4d65260fcf4c4bb31931ef0082268737cfa63720aa497179074d6856fbf08f2afea13bdfd124d9e
-  data.tar.gz: fa549524250d3431623f06ac0bcdd7746032a388f8c546fb759913ec1ec63927147e19b119574a25603c41c1900ccec560cf5ba353ebeb903d1dd8b539a6ce46
+  metadata.gz: 0b6798e66984df642eb6fec17b0bf88a6d37d21c10b909558d6ca069a0fab63e347a76fc01106cf7993bf23f468c62da060a296341792b1058bedaa682d4eaee
+  data.tar.gz: ae1a412572613d73f47b75aed52c63211f50b90d2a3a0f22d7a8d86a7b9dcf586553d25bf2792b708eb4215c864513c102febc43519eae4ce241c194fdd529e1

data/README.md

@@ -1,6 +1,6 @@
 # Reversi
 
-[![Gem Version](https://badge.fury.io/rb/reversi.svg)](http://badge.fury.io/rb/reversi) [![Build Status](https://travis-ci.org/seinosuke/reversi.svg?branch=master)](https://travis-ci.org/seinosuke/reversi)  
+[![Gem Version](https://badge.fury.io/rb/reversi.svg)](http://badge.fury.io/rb/reversi) [![Build Status](https://travis-ci.org/seinosuke/reversi.svg?branch=master)](https://travis-ci.org/seinosuke/reversi) [![Inline docs](http://inch-ci.org/github/seinosuke/reversi.svg?branch=master)](http://inch-ci.org/github/seinosuke/reversi)  
 A Ruby Gem to play reversi game. You can enjoy a game on the command line or easily make your original reversi game programs.  
 
 ![reversi.gif](https://github.com/seinosuke/reversi/blob/master/images/reversi.gif)
@@ -53,19 +53,22 @@ Use `Reversi.configure` to configure setting for a reversi game.
 * `disk_w` A string of the black disks. ( 'w' )
 * `disk_color_b` A color of the black disks. ( 0 )
 * `disk_color_w` A color of the black disks. ( 0 )
-* `initial_position` The initial positions of each disk on the board. ( {:black => [[:d, 5], [:e, 4]], :white => [[:d, 4], [:e, 5]]} )
+* `initial_position` The initial positions of each disk on the board.
 * `progress` Whether or not the progress of the game is displayed. ( false )
 * `stack_limit` The upper limit number of times of use repeatedly `Reversi::Board#undo!` . ( 3 )
 
 A string and a color of the disks are reflected on `game.board.to_s` .  
 You can choose from 9 colors, black, red, green, yellow, blue, magenda, cyan, white and gray.  
 
+The default of `initial_position` is `{:black => [[4, 5], [5, 4]], :white => [[4, 4], [5, 5]]}` .
+
 Using `Reversi.reset` method, you can reset all options to the default values.
 
 ### Human vs Computer
 
 Set `Reversi::Player::Human` to player_b or player_w, and run. Please input your move (for example: d3). This program is terminated when this game is over or when you input `q` or `exit`.  
 
+
 ```ruby
 Reversi.configure do |config|
   config.player_b = Reversi::Player::Human
@@ -75,13 +78,14 @@ game = Reversi::Game.new
 game.start
 ```
 
+
 ### Your Original Player
 
 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.
+`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.
 
- * Example of Random AI
+ * **Example of Random Player**
 
 ```ruby
 class MyAI < Reversi::Player::BasePlayer
@@ -99,8 +103,78 @@ game = Reversi::Game.new
 game.start
 ```
 
- * Other examples of algorithm  
-Please see [Reversi::Player::MinMaxAI](https://github.com/seinosuke/reversi/blob/master/lib/reversi/player/min_max_ai.rb) or [Reversi::Player::NegaMaxAI](https://github.com/seinosuke/reversi/blob/master/lib/reversi/player/nega_max_ai.rb) . These are examples of the player that can read the next three moves and evaluate a game state based on the positions of the disks. If you want to read the next more than three moves, set `stack_limit` to the number.
+ * **Example of MinMax algorithm**
+
+```ruby
+class MyAI < Reversi::Player::BasePlayer
+
+  def initialize(_color, _board)
+    super
+
+    # The evaluation value at each position.
+    points = [
+      100, -10,  0, -1, -1,  0, -10, 100,
+      -10, -30, -5, -5, -5, -5, -30, -10,
+        0,  -5,  0, -1, -1,  0,  -5,   0,
+       -1,  -5, -1, -1, -1, -1,  -5,  -1,
+       -1,  -5, -1, -1, -1, -1,  -5,  -1,
+        0,  -5,  0, -1, -1,  0,  -5,   0,
+      -10, -30, -5, -5, -5, -5, -30, -10,
+      100, -10,  0, -1, -1,  0, -10, 100
+    ]
+    @evaluation_value = 
+      Hash[(1..8).map{ |x| (1..8).map{ |y| [[x, y], points.shift] } }.flatten(1) ]
+  end
+
+  def move(board)
+    moves = next_moves.map{ |v| v[:move] }
+    return if moves.empty?
+    next_move = moves.map do |move|
+      { :move => move, :point => evaluate(move, board, 3, true) }
+    end.max_by{ |v| v[:point] }[:move]
+    put_disk(*next_move)
+  end
+
+  def evaluate(move, board, depth, color)
+    # Move to the child node.
+    put_disk(*move, color)
+
+    # Acquire the branches of this node.
+    moves = next_moves(!color).map{ |v| v[:move] }
+
+    # Evaluate a current game-state when a search reaches the leaf node.
+    if depth == 1
+      status[:mine].inject(0){ |sum, xy| sum + @evaluation_value[xy] }
+    elsif moves.empty?
+      -100
+
+    # Select one of the child nodes
+    # when the current node is not the leaf node.
+    # Return a minimum value if it is a my move, or
+    # return a maximum value if it is an opponent's move.
+    else
+      values = moves.map{ |move| evaluate(move, board, depth - 1, !color) }
+      case depth
+      when ->(n){ n.odd? }  then values.min
+      when ->(n){ n.even? } then values.max end
+    end
+
+  # Return to a parent node.
+  ensure
+    board.undo!
+  end
+end
+
+Reversi.configure do |config|
+  config.player_b = MyAI
+end
+
+game = Reversi::Game.new
+game.start
+```
+
+ * **Other examples of algorithm**  
+Please see [Reversi::Player::NegaMaxAI](https://github.com/seinosuke/reversi/blob/master/lib/reversi/player/nega_max_ai.rb) or [Reversi::Player::AlphaBetaAI](https://github.com/seinosuke/reversi/blob/master/lib/reversi/player/alpha_beta_ai.rb) . These are examples of the player that can read the next three moves and evaluate a game state based on the positions of the disks. If you want to read the next more than three moves, set `stack_limit` to the number.
 
 ## Contributing
 

data/ext/reversi/reversi.c

@@ -1,16 +1,31 @@
 #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);
 
-  rb_define_private_method(reversi_board, "board_initialize", board_initialize, 0);
+  /* 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);
 
+  /* 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);
@@ -21,6 +36,11 @@ void Init_reversi(void) {
   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;
@@ -39,6 +59,11 @@ static VALUE board_initialize(VALUE self) {
   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();
@@ -54,6 +79,11 @@ static VALUE board_columns_getter(VALUE self) {
   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();
@@ -73,6 +103,10 @@ static VALUE board_stack_getter(VALUE self) {
   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);
@@ -80,11 +114,22 @@ static VALUE board_undo(VALUE self) {
   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();
@@ -123,6 +168,13 @@ static VALUE board_status(VALUE self) {
   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;
@@ -137,12 +189,25 @@ static VALUE board_openness(VALUE self, VALUE x, VALUE y) {
   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;
@@ -156,6 +221,12 @@ static VALUE board_count_disks(VALUE self, VALUE color) {
   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();
@@ -174,6 +245,13 @@ static VALUE board_next_moves(VALUE self, VALUE color) {
   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);
@@ -182,6 +260,14 @@ static VALUE board_put_disk(VALUE self, VALUE x, VALUE y, VALUE 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;
@@ -201,6 +287,10 @@ static VALUE board_flip_disks(VALUE self, VALUE x, VALUE y, VALUE 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);
@@ -214,6 +304,10 @@ void flip_disk(VALUE self, int x, int y, int dx, int dy, int 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;
@@ -232,6 +326,9 @@ int can_put(VALUE self, int x, int y, int color){
   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);

data/ext/reversi/reversi.h

@@ -3,6 +3,7 @@
 #include <memory.h>
 
 void Init_board(void);
+
 static VALUE board_alloc(VALUE class);
 static VALUE board_initialize(VALUE self);
 static VALUE board_columns_getter(VALUE self);
@@ -26,18 +27,3 @@ void pop_stack(int ary[10][10]);
 int stack_size(void);
 void delete_old(void);
 void reset_stack(void);
-
-struct stack{
-  int stack_columns[10][10];
-  struct stack *next;
-};
-struct stack *head = NULL;
-
-struct board {
-  int columns[10][10];
-};
-
-static VALUE board_alloc(VALUE class) {
-  struct board *ptr = ALLOC(struct board);
-  return Data_Wrap_Struct(class, 0, -1, ptr);
-}

data/lib/reversi/board.rb

@@ -120,7 +120,7 @@ module Reversi
     end
 
     # Flips the opponent's disks between a new disk and another disk of my color.
-    # the invalid move has no effect.
+    # The invalid move has no effect.
     #
     # @param x [Symbol, Integer] the column number
     # @param y [Integer] the row number

data/lib/reversi/configuration.rb

@@ -20,7 +20,7 @@ module Reversi
       :disk_w => 'w',
       :disk_color_b => 0,
       :disk_color_w => 0,
-      :initial_position => {:black => [[:d, 5], [:e, 4]], :white => [[:d, 4], [:e, 5]]},
+      :initial_position => {:black => [[4, 5], [5, 4]], :white => [[4, 4], [5, 5]]},
       :progress => false,
       :stack_limit => 3
     }

data/lib/reversi/player.rb

@@ -3,6 +3,7 @@ module Reversi
     autoload :RandomAI, "reversi/player/random_ai"
     autoload :NegaMaxAI, "reversi/player/nega_max_ai"
     autoload :MinMaxAI, "reversi/player/min_max_ai"
+    autoload :AlphaBetaAI, "reversi/player/alpha_beta_ai"
     autoload :Human, "reversi/player/human"
   end
 end

data/lib/reversi/player/alpha_beta_ai.rb

@@ -0,0 +1,70 @@
+module Reversi::Player
+  class AlphaBetaAI < BasePlayer
+
+    N = 10000.freeze
+
+    def initialize(_color, _board)
+      super
+
+      points = [
+        100, -10,  0, -1, -1,  0, -10, 100,
+        -10, -30, -5, -5, -5, -5, -30, -10,
+          0,  -5,  0, -1, -1,  0,  -5,   0,
+         -1,  -5, -1, -1, -1, -1,  -5,  -1,
+         -1,  -5, -1, -1, -1, -1,  -5,  -1,
+          0,  -5,  0, -1, -1,  0,  -5,   0,
+        -10, -30, -5, -5, -5, -5, -30, -10,
+        100, -10,  0, -1, -1,  0, -10, 100
+      ]
+      @evaluation_value = 
+        Hash[(1..8).map{ |x| (1..8).map{ |y| [[x, y], points.shift] } }.flatten(1) ]
+    end
+
+    def move(board)
+      moves = next_moves.sort_by{ |v| v[:openness] }.map{ |v| v[:move] }
+      return if moves.empty?
+      alpha = -N; beta = N
+      next_move = moves.map do |move|
+        { :move => move, :point => evaluate(move, board, alpha, beta, 3, true) }
+      end.max_by{ |v| v[:point] }[:move]
+      put_disk(*next_move)
+    end
+
+    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] }
+
+      if depth == 1
+        status[:mine].inject(0){ |sum, xy| sum + @evaluation_value[xy] }
+
+      elsif moves.empty?
+        case depth
+        when ->(n){ n.odd? }  then alpha
+        when ->(n){ n.even? } then beta end
+
+      else
+        case depth
+        when ->(n){ n.odd? }
+          beta = N
+          moves.each do |move|
+            val = evaluate(move, board, alpha, beta, depth - 1, !color)
+            beta = val if val < beta
+            return alpha if alpha > beta
+          end
+          beta
+        when ->(n){ n.even? }
+          alpha = -N
+          moves.each do |move|
+            val = evaluate(move, board, alpha, beta, depth - 1, !color)
+            alpha = val if val > alpha
+            return beta if alpha > beta
+          end
+          alpha
+        end
+      end
+
+    ensure
+      board.undo!
+    end
+  end
+end

data/lib/reversi/player/min_max_ai.rb

@@ -4,7 +4,7 @@ module Reversi::Player
     def initialize(_color, _board)
       super
 
-      point = [
+      points = [
         100, -10,  0, -1, -1,  0, -10, 100,
         -10, -30, -5, -5, -5, -5, -30, -10,
           0,  -5,  0, -1, -1,  0,  -5,   0,
@@ -15,17 +15,15 @@ module Reversi::Player
         100, -10,  0, -1, -1,  0, -10, 100
       ]
       @evaluation_value = 
-        Hash[(1..8).map{ |x| (1..8).map{ |y| [[x, y], point.shift] } }.flatten(1) ]
+        Hash[(1..8).map{ |x| (1..8).map{ |y| [[x, y], points.shift] } }.flatten(1) ]
     end
 
     def move(board)
       moves = next_moves.map{ |v| v[:move] }
       return if moves.empty?
-
       next_move = moves.map do |move|
-        { :move => move, :point => evaluate(move, board, 1, true) }
-      end
-      .max_by{ |v| v[:point] }[:move]
+        { :move => move, :point => evaluate(move, board, 3, true) }
+      end.max_by{ |v| v[:point] }[:move]
       put_disk(*next_move)
     end
 
@@ -33,12 +31,13 @@ module Reversi::Player
       put_disk(*move, color)
       moves = next_moves(!color).map{ |v| v[:move] }
 
-      if depth == 3
+      if depth == 1
         status[:mine].inject(0){ |sum, xy| sum + @evaluation_value[xy] }
       elsif moves.empty?
         -100
+
       else
-        values = moves.map{ |move| evaluate(move, board, depth + 1, !color) }
+        values = moves.map{ |move| evaluate(move, board, depth - 1, !color) }
         case depth
         when ->(n){ n.odd? }  then values.min
         when ->(n){ n.even? } then values.max end

data/lib/reversi/player/nega_max_ai.rb

@@ -4,7 +4,7 @@ module Reversi::Player
     def initialize(_color, _board)
       super
 
-      point = [
+      points = [
         100, -10,  0, -1, -1,  0, -10, 100,
         -10, -30, -5, -5, -5, -5, -30, -10,
           0,  -5,  0, -1, -1,  0,  -5,   0,
@@ -15,17 +15,15 @@ module Reversi::Player
         100, -10,  0, -1, -1,  0, -10, 100
       ]
       @evaluation_value = 
-        Hash[(1..8).map{ |x| (1..8).map{ |y| [[x, y], point.shift] } }.flatten(1) ]
+        Hash[(1..8).map{ |x| (1..8).map{ |y| [[x, y], points.shift] } }.flatten(1) ]
     end
 
     def move(board)
       moves = next_moves.map{ |v| v[:move] }
       return if moves.empty?
-
       next_move = moves.map do |move|
-        { :move => move, :point => evaluate(move, board, 1, true) }
-      end
-      .max_by{ |v| v[:point] }[:move]
+        { :move => move, :point => evaluate(move, board, 3, true) }
+      end.max_by{ |v| v[:point] }[:move]
       put_disk(*next_move)
     end
 
@@ -33,12 +31,12 @@ module Reversi::Player
       put_disk(*move, color)
       moves = next_moves(!color).map{ |v| v[:move] }
 
-      if depth == 3
+      if depth == 1
         status[:mine].inject(0){ |sum, xy| sum + @evaluation_value[xy] }
       elsif moves.empty?
         -100
       else
-        -( moves.map{ |move| evaluate(move, board, depth + 1, !color) }.max )
+        -( moves.map{ |move| evaluate(move, board, depth - 1, !color) }.max )
       end
 
     ensure

data/lib/reversi/version.rb

@@ -1,3 +1,3 @@
 module Reversi
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reversi
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - seinosuke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-11 00:00:00.000000000 Z
+date: 2015-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -50,6 +50,7 @@ files:
 - lib/reversi/configuration.rb
 - lib/reversi/game.rb
 - lib/reversi/player.rb
+- lib/reversi/player/alpha_beta_ai.rb
 - lib/reversi/player/base_player.rb
 - lib/reversi/player/human.rb
 - lib/reversi/player/min_max_ai.rb