reversi 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b74434187306f90d0e807720becda4d613e203d
-  data.tar.gz: 24ec4031e6efc0b91abb9376f591351410fa11bc
+  metadata.gz: dde2e7d7a4f73ef89fbdc626ff5f06d22e0451fa
+  data.tar.gz: d3d2a7f4eea6769ea366c8cd3a1a059238cbf0f4
 SHA512:
-  metadata.gz: fab9a5fee9f1208adc01bf6a80e40a2392db4f2114510389cbfc4ec1f0ee1accd700daf47818a89003e2dbf61a77123d7b6c3d13061f08e4e5f6f62759527c0b
-  data.tar.gz: 2b57d30206e350947c5cb406bca275bed3e4eb897dbf7f801813051a67c37452ae036f199a45ea319e9aabec8ab103be5ddf019d55c9905f43e5c37eca3f21bd
+  metadata.gz: 96c2d82cfb35399f3951b62c08a18d024b564a146d588311ce3ef1790d512be2d9d77e1def514be5fd23dae97509a979cfb5308c9b03a2e92d55365a5375fefa
+  data.tar.gz: 32d24821205506520d37fec291679fa21ca5e30369bdafa1ed5f7a8772008f9b207189864ce286f9a2dd16b23030b2af11ddafa4d680ec7287bd6580e4536ba2

data/.gitignore

@@ -7,6 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/test/
 *.bundle
 *.so
 *.o

data/Gemfile

@@ -1,4 +1,18 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in reversi.gemspec
+gem 'rake'
+gem 'yard'
+
+group :development do
+  gem 'pry'
+  gem 'pry-doc'
+  gem 'pry-stack_explorer'
+end
+
+group :test do
+  gem 'rspec', '>= 3.1'
+  gem 'guard-rspec', '4.5.0'
+  gem 'libnotify', '0.9.1'
+end
+
 gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch('spec/spec_helper.rb')     { 'spec' }
+
+  watch(/lib\/(.+)\.rb/)           { 'spec' }
+  watch(/lib\/reversi\/(.+)\.rb/)  { 'spec' }
+end

data/README.md

@@ -1,5 +1,9 @@
 # Reversi
 
+[![Gem Version](https://badge.fury.io/rb/reversi.svg)](http://badge.fury.io/rb/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](https://github.com/seinosuke/reversi/blob/master/images/reversi.gif)
 
 ## Installation
 
@@ -19,10 +23,85 @@ Or install it yourself as:
 
 ## Usage
 
+Run a demo program in this introduction.
+
+```ruby
+require 'reversi'
+
+Reversi.configure do |config|
+  config.disk_color_b = 'cyan'
+  config.disk_b = "O"
+  config.disk_w = "O"
+  config.progress = true
+end
+
+game = Reversi::Game.new
+game.start
+puts "black #{game.board.status[:black].size}"
+puts "white #{game.board.status[:white].size}"
+```
+
+### Configuration
+
+Use `Reversi.configure` to configure setting for a reversi game.  
+
+`name` description... (default value)  
+
+* `player_b` A player having the first move uses this class object. (Reversi::Player::RandomAI)
+* `player_w` A player having the passive move uses this class object. (Reversi::Player::RandomAI)
+* `disk_b` A string of the black disks. ('b')
+* `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)
+* `progress` Whether or not the progress of the game is displayed. (false)
+* `stack_limit` The upper limit number of times of use `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.  
+
+### 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
+end
+
+game = Reversi::Game.new
+game.start
+```
+
+### My AI
+
+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.
+
+ * Example of Random AI
+
+```ruby
+class MyAI < Reversi::Player::BasePlayer
+  def move(board)
+    moves = next_moves.map{ |v| v[:move] }
+    put_disk(*moves.sample) unless moves.empty?
+  end
+end
+
+Reversi.configure do |config|
+  config.player_b = MyAI
+end
+
+game = Reversi::Game.new
+game.start
+```
+
+ * Example of Negamax Algorithm  
+Please see `Reversi::Player::NegamaxAI` .
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/reversi/fork )
+1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/Rakefile

@@ -1,7 +1,10 @@
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
 
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', 'lib/*.rb']
+end
 

data/lib/reversi/board.rb

@@ -0,0 +1,215 @@
+module Reversi
+  class Board
+    attr_reader :options, :columns, :stack
+
+    COORDINATES = (:a..:h).map{ |x| (1..8).map{ |y| [x, y] } }.flatten(1).freeze
+
+    DISK = {
+      :none  =>  0,
+      :wall  =>  2,
+      :black => -1,
+      :white =>  1
+    }.freeze
+
+    DISK_COLOR = {
+      :black   => 30,
+      :red     => 31,
+      :green   => 32,
+      :yellow  => 33,
+      :blue    => 34,
+      :magenda => 35,
+      :cyan    => 36,
+      :white   => 37,
+      :gray    => 90
+    }.freeze
+
+    # Initializes a new Board object.
+    #
+    # @see Reversi::Game
+    # @see Reversi::Configration
+    # @return [Reversi::Board]
+    def initialize(options = {})
+      @options = options
+      @stack = []
+      [: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
+      @columns = (0..9).map{ (0..9).map{ |_| DISK[:none] } }
+      put_disk(4, 4, :white); put_disk(5, 5, :white)
+      put_disk(4, 5, :black); put_disk(5, 4, :black)
+      @columns.each do |col|
+        col[0] = 2; col[-1] = 2
+      end.tap do |cols|
+        cols[0].fill(2); cols[-1].fill(2)
+      end
+    end
+
+    # Returns a string of the game board in human-readable form.
+    #
+    # @return [String]
+    def to_s
+      "     #{(:a..:h).to_a.map(&:to_s).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"
+        end
+      end
+      .map{ |e| "| #{e} |" }.join }.map{ |e| e.gsub(/\|\|/, "|") }
+      .tap{ |rows| break (0..7).to_a.map{ |i| " #{i+1} " << rows[i] } }
+      .join("\n   #{"+---"*8}+\n") <<
+      "\n   #{"+---"*8}+\n"
+    end
+
+    # Pushes an array of the game board onto a stack.
+    # The stack size limit is 3(default).
+    def push_stack
+      @stack.push(Marshal.load(Marshal.dump(@columns)))
+      @stack.shift if @stack.size > @options[:stack_limit]
+    end
+
+    # Pops an array of the game board off of the stack,
+    # and that is stored in the instance variable.(`@columns`)
+    #
+    # @param num [Integer] Be popped from the stack by the supplied number of times.
+    def undo!(num = 1)
+      num.times{ @columns = @stack.pop }
+    end
+
+    # Returns a hash containing the coordinates of each color.
+    #
+    # @return [Hash{Symbol => Array<Symbol, Integer>}]
+    def status
+      Hash[*[:none, :black, :white].map do |key|
+        [key, COORDINATES.map{ |x, y| [x, y] if key == at(x, y) }.compact]
+      end.flatten(1)]
+    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).to_a.index(x) + 1 if x.is_a? Symbol
+      ([-1,0,1].product([-1,0,1]) - [[0, 0]]).inject(0) do |sum, (dx, dy)|
+        sum + (@columns[x + dx][y + dy] == 0 ? 1 : 0)
+      end
+    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).to_a.index(x) + 1 if x.is_a? Symbol
+      DISK.key(@columns[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)
+      @columns.flatten.inject(0) do |sum, e|
+        sum + (e == DISK[color] ? 1 : 0)
+      end
+    end
+
+    # Returns an array of the next moves.
+    #
+    # @param color [Symbol]
+    # @return [Array<Array<Symbol, Integer>>]
+    def next_moves(color)
+      @columns[1..8].map{ |col| col[1..-2] }
+      .flatten.each_with_index.inject([]) do |list, (_, i)|
+        list << (puttable?(*COORDINATES[i], color) ? COORDINATES[i] : nil)
+      end.compact
+    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).to_a.index(x) + 1 if x.is_a? Symbol
+      @columns[x][y] = DISK[color.to_sym]
+    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).to_a.index(x) + 1 if x.is_a? Symbol
+      [-1,0,1].product([-1,0,1]).each do |dx, dy|
+        next if dx == 0 && dy == 0
+        # 隣接石が異色であったらflippable?でひっくり返せるか（挟まれているか）確認
+        if @columns[x + dx][y + dy] == DISK[color]*(-1)
+          flip_disk(x, y, dx, dy, color) if flippable?(x, y, dx, dy, color)
+        end
+      end
+    end
+
+    private
+
+    # Flips the opponent's disks on one of these straight lines
+    # between a new disk and another disk of my color.
+    #
+    # @param x [Symbol, Integer] the column number
+    # @param y [Integer] the row number
+    # @param dx [Integer] a horizontal difference
+    # @param dy [Integer] a verticaldistance
+    # @param color [Symbol]
+    def flip_disk(x, y, dx, dy, color)
+      return if [DISK[:wall], DISK[:none], DISK[color]].include?(@columns[x+dx][y+dy])
+      @columns[x+dx][y+dy] = DISK[color]
+      flip_disk(x+dx, y+dy, dx, dy, color)
+    end
+
+    # Whether or not a player can place a new disk on specified position.
+    # Returns true if the move is valid.
+    #
+    # @param x [Symbol, Integer] the column number
+    # @param y [Integer] the row number
+    # @param color [Symbol]
+    # @return [Boolean]
+    def puttable?(x, y, color)
+      x = (:a..:h).to_a.index(x) + 1 if x.is_a? Symbol
+      return false if @columns[x][y] != 0
+      [-1,0,1].product([-1,0,1]).each do |dx, dy|
+        next if dx == 0 && dy == 0
+        if @columns[x + dx][y + dy] == DISK[color]*(-1)
+          return true if flippable?(x, y, dx, dy, color)
+        end
+      end
+      false
+    end
+
+    # Whether or not a player can flip the opponent's disks.
+    #
+    # @param x [Symbol, Integer] the column number
+    # @param y [Integer] the row number
+    # @param dx [Integer] a horizontal difference
+    # @param dy [Integer] a verticaldistance
+    # @param color [Symbol]
+    # @return [Boolean]
+    def flippable?(x, y, dx, dy, color)
+      loop do
+        x += dx; y += dy
+        return true if @columns[x][y] == DISK[color]
+        break if [DISK[:wall] ,DISK[:none]].include?(@columns[x][y])
+      end
+      false
+    end
+  end
+end

data/lib/reversi/configuration.rb

@@ -0,0 +1,36 @@
+module Reversi
+  module Configuration
+
+    OPTIONS_KEYS = [
+      :player_b,
+      :player_w,
+      :disk_b,
+      :disk_w,
+      :disk_color_b,
+      :disk_color_w,
+      :progress,
+      :stack_limit
+    ].freeze
+
+    attr_accessor *OPTIONS_KEYS
+
+    def configure
+      yield self
+    end
+
+    def options
+      Hash[*OPTIONS_KEYS.map{|key| [key, send(key)]}.flatten]
+    end
+
+    def set_defaults
+      self.player_b     ||= Reversi::Player::RandomAI
+      self.player_w     ||= Reversi::Player::RandomAI
+      self.disk_b       ||= "b"
+      self.disk_w       ||= "w"
+      self.disk_color_b ||= 0
+      self.disk_color_w ||= 0
+      self.progress     ||= false
+      self.stack_limit  ||= 3
+    end
+  end
+end

data/lib/reversi/game.rb

@@ -0,0 +1,99 @@
+module Reversi
+  class Game
+    attr_accessor *Configuration::OPTIONS_KEYS
+    attr_reader :options, :board, :vs_human, :status
+
+    # Initializes a new Board object.
+    def initialize(options = {})
+      reset(options)
+    end
+
+    # Set the option values and start a game.
+    #
+    # @see #run
+    def start(options = {})
+      reset(options)
+      mode = {:progress => @progress, :vs_human => @vs_human}
+      run(mode)
+    end
+
+    private
+
+    # Reset the instance variable, `@board`.
+    def reset(options = {})
+      load_config(options)
+      @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)
+    end
+
+    # Load the configuration.
+    def load_config(options = {})
+      Reversi.set_defaults
+      @options = Reversi.options.merge(options)
+      Configuration::OPTIONS_KEYS.each do |key|
+        send("#{key}=".to_sym, @options[key])
+      end
+
+      if [@player_b, @player_w].include? Reversi::Player::Human
+        @vs_human = true
+        @progress = false
+      end
+      @vs_human ||= false
+    end
+
+    # Execute a game and run until the end of the game.
+    #
+    # @option mode [Boolean] :progress Display the progress of the game.
+    # @option mode [Boolean] :vs_human 
+    def run(mode = {})
+      show_board if mode[:progress]
+      loop do
+        break if game_over?
+        @status = @board.status
+        @player_b.move(@board); check_move(:black)
+        show_board if mode[:progress]
+
+        @status = @board.status
+        @player_w.move(@board); check_move(:white)
+        show_board if mode[:progress]
+      end
+      puts @board.to_s if mode[:progress] || mode[:vs_human]
+    rescue Interrupt
+      exit 1
+    end
+
+    # Show the current state of this game board.
+    def show_board
+      puts @board.to_s
+      printf "\e[#{18}A"; STDOUT.flush; sleep 0.1
+    end
+
+    # Checks a move to make sure it is valid.
+    def check_move(color)
+      blank_diff = @status[:none].size - @board.count_disks(:none)
+
+      case blank_diff
+      when 1
+        if (@board.count_disks(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
+          raise MoveError, "When a player can't make a valid move, you must not place a new disk."
+        end
+      else
+        raise MoveError, "A player must place a new disk on the board."
+      end
+    end
+
+    # Whether or not this game is over.
+    # Both players can't find a next move, that's the end of the game.
+    def game_over?
+      @player_w.next_moves.empty? && @player_b.next_moves.empty?
+    end
+  end
+end

data/lib/reversi/player/base_player.rb

@@ -0,0 +1,76 @@
+module Reversi::Player
+  class BasePlayer
+    attr_reader :my_color, :opponent_color, :board
+
+    # Initializes a new BasePlayer object.
+    def initialize(color, board)
+      @my_color = color
+      @opponent_color = (@my_color == :white ? :black : :white)
+      @board = board
+    end
+
+    # Override this method in your original subclass.
+    def move(board)
+    end
+
+    # Places a supplied color's disk on specified position,
+    # and flips the opponent's disks.
+    #
+    # @param x [Symbol, Integer] the column number
+    # @param y [Integer] the row number
+    # @param my_color [Boolean] my color or opponent's color
+    def put_disk(x, y, my_color = true)
+      @board.push_stack
+      color = my_color ? @my_color : @opponent_color
+      x = (:a..:h).to_a.index(x) + 1 if x.is_a? Symbol
+      diff = flip_disks(x, y, color)
+      if diff.empty?
+        raise Reversi::MoveError, "A player must flip at least one or more opponent's disks."
+      end
+      @board.put_disk(x, y, color)
+    end
+
+    # Returns an array of the next moves.
+    #
+    # @param my_color [Boolean] my color or opponent's color
+    # @return [Hash] the next moves
+    def next_moves(my_color = true)
+      color = my_color ? @my_color : @opponent_color
+      @board.next_moves(color).map do |move|
+        diff = flip_disks(*move, color)
+        openness = diff.inject(0){ |sum, (x, y)| sum + @board.openness(x, y) }
+        # undo the flipped disks
+        diff.each{ |x, y| @board.put_disk(x, y, my_color ? @opponent_color : @my_color) }
+        {:move => move, :openness => openness, :result => diff}
+      end
+    end
+
+    # Returns a number of the supplied color's disks.
+    #
+    # @param my_color [Boolean] my color or opponent's color
+    # @return [Integer] a number of the supplied color's disks
+    def count_disks(my_color = true)
+      @board.count_disks(my_color ? @my_color : @opponent_color)
+    end
+
+    # Returns a hash containing the coordinates of each color.
+    #
+    # @return [Hash{Symbol => Array<Symbol, Integer>}]
+    def status
+      convert = {
+        :black => @my_color == :black ? :mine : :opponent,
+        :white => @my_color == :white ? :mine : :opponent,
+        :none  => :none }
+      Hash[*@board.status.map{ |k, v| [convert[k], v] }.flatten(1)]
+    end
+
+    private
+
+    def flip_disks(x, y, color)
+      before = @board.status[color]
+      @board.flip_disks(x, y, color)
+      after = @board.status[color]
+      after - before
+    end
+  end
+end

data/lib/reversi/player/human.rb

@@ -0,0 +1,49 @@
+module Reversi::Player
+  class Human < BasePlayer
+
+    def move(board)
+      return if next_moves.empty?
+      puts board.to_s
+      input_move
+      printf "\e[#{18}A"; STDOUT.flush
+      puts board.to_s; sleep 0.5
+      printf "\e[#{18}A"; STDOUT.flush
+    end
+
+    private
+
+    def input_move
+      loop do
+        print "#{@my_color}: "
+        @input_move = gets.chomp.split("")
+        exit if [['q'], ['e','x','i','t']].include? @input_move
+        redo if check_size == :redo
+        @input_move[0] = @input_move[0].to_sym
+        @input_move[1] = @input_move[1].to_i
+        printf "\e[#{1}A"; STDOUT.flush
+        print "#{" "*9}"
+        printf "\e[#{9}D"; STDOUT.flush
+        redo if check_valid == :redo
+        put_disk(*@input_move)
+        break
+      end
+    end
+
+    def check_size
+      unless @input_move.size == 2
+        printf "\e[#{1}A"; STDOUT.flush
+        print "#{" "*(@input_move.join.size + 7)}"
+        printf "\e[#{@input_move.join.size + 7}D"; STDOUT.flush
+        return :redo
+      end
+      :valid
+    end
+
+    def check_valid
+      unless next_moves.map{ |v| v[:move] }.include?(@input_move)
+        return :redo
+      end
+      :valid
+    end
+  end
+end

data/lib/reversi/player/negamax_ai.rb

@@ -0,0 +1,42 @@
+module Reversi::Player
+  class NegamaxAI < Reversi::Player::BasePlayer
+
+    POINT = {
+      [:a, 1] => 100, [:b, 1] => -10, [:c, 1] =>  0, [:d, 1] => -1, [:e, 1] => -1, [:f, 1] =>  0, [:g, 1] => -10, [:h, 1] => 100,
+      [:a, 2] => -10, [:b, 2] => -30, [:c, 2] => -5, [:d, 2] => -5, [:e, 2] => -5, [:f, 2] => -5, [:g, 2] => -30, [:h, 2] => -10,
+      [:a, 3] =>   0, [:b, 3] =>  -5, [:c, 3] =>  0, [:d, 3] => -1, [:e, 3] => -1, [:f, 3] =>  0, [:g, 3] =>  -5, [:h, 3] =>   0,
+      [:a, 4] =>  -1, [:b, 4] =>  -5, [:c, 4] => -1, [:d, 4] => -1, [:e, 4] => -1, [:f, 4] => -1, [:g, 4] =>  -5, [:h, 4] =>  -1,
+      [:a, 5] =>  -1, [:b, 5] =>  -5, [:c, 5] => -1, [:d, 5] => -1, [:e, 5] => -1, [:f, 5] => -1, [:g, 5] =>  -5, [:h, 5] =>  -1,
+      [:a, 6] =>   0, [:b, 6] =>  -5, [:c, 6] =>  0, [:d, 6] => -1, [:e, 6] => -1, [:f, 6] =>  0, [:g, 6] =>  -5, [:h, 6] =>   0,
+      [:a, 7] => -10, [:b, 7] => -30, [:c, 7] => -5, [:d, 7] => -5, [:e, 7] => -5, [:f, 7] => -5, [:g, 7] => -30, [:h, 7] => -10,
+      [:a, 8] => 100, [:b, 8] => -10, [:c, 8] =>  0, [:d, 8] => -1, [:e, 8] => -1, [:f, 8] =>  0, [:g, 8] => -12, [:h, 8] => 100
+    }.freeze
+
+    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]
+      put_disk(*next_move)
+    end
+
+    def evaluate(move, board, depth, color)
+      put_disk(*move, color)
+      moves = next_moves(!color).map{ |v| v[:move] }
+
+      if depth == 3
+        status[:mine].inject(0){ |sum, xy| sum + POINT[xy] }
+      elsif moves.empty?
+        -100
+      else
+        -( moves.map{ |move| evaluate(move, board, depth + 1, !color) }.max )
+      end
+
+    ensure
+      board.undo!
+    end
+  end
+end

data/lib/reversi/player/random_ai.rb

@@ -0,0 +1,9 @@
+module Reversi::Player
+  class RandomAI < BasePlayer
+
+    def move(board)
+      moves = next_moves.map{ |v| v[:move] }
+      put_disk(*moves.sample) unless moves.empty?
+    end
+  end
+end

data/lib/reversi/player.rb

@@ -0,0 +1,7 @@
+module Reversi
+  module Player
+    autoload :RandomAI, "reversi/player/random_ai"
+    autoload :NegamaxAI, "reversi/player/negamax_ai"
+    autoload :Human, "reversi/player/human"
+  end
+end

data/lib/reversi/version.rb

@@ -1,3 +1,3 @@
 module Reversi
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/reversi.rb

@@ -1,5 +1,12 @@
 require "reversi/version"
+require "reversi/player"
+require "reversi/player/base_player"
+require "reversi/board"
+require "reversi/configuration"
+require "reversi/game"
 
 module Reversi
-  # Your code goes here...
+  extend Configuration
+
+  class MoveError < StandardError; end
 end

data/reversi.gemspec

@@ -7,17 +7,21 @@ Gem::Specification.new do |spec|
   spec.name          = "reversi"
   spec.version       = Reversi::VERSION
   spec.authors       = ["seinosuke"]
-  spec.email         = ["seinosuke.3606@gmail.com"]
-  spec.summary       = %q{Reversi}
-  spec.description   = %q{A reversi game program.}
-  spec.homepage      = ""
+  spec.summary       = %q{A Ruby Gem to play reversi game.}
+  spec.homepage      = "https://github.com/seinosuke/reversi"
   spec.license       = "MIT"
 
+  spec.required_ruby_version = '>= 1.9.3'
+
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.description   = <<-END
+A Ruby Gem to play reversi game. You can enjoy a game on the command line
+or easily make your original reversi game programs.
+END
 end

data/spec/base_player_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Reversi::Player::BasePlayer do
+  let(:game) { Reversi::Game.new }
+  let(:player) { game.player_b }
+  let(:board) { game.board }
+
+  describe "#put_disk" do
+    context "when a player make a valid move" do
+      it "flips the opponent's disks between a new disk and my disk" do
+        expect{ player.put_disk(:d, 3) }.to change{ board.status[:black].size }.by(2)
+      end
+    end
+
+    context "when a player make an invalid move" do
+      it "Reversi::MoveError raised" do
+        expect{ player.put_disk(:a, 1) }.to raise_error Reversi::MoveError
+      end
+    end
+
+    context "when the third argument is `false`" do
+      it "makes a opponent's move" do
+        expect{ player.put_disk(:e, 3, false) }.to change{ board.status[:white].size }.by(2)
+      end
+    end
+  end
+
+  describe "#next_moves" do
+    context "when the first argument is omitted" do
+      it do
+        ans = [[:c, 4], [:d, 3], [:e, 6], [:f, 5]]
+        expect(player.next_moves.map{ |move| move[:move] }).to eq ans
+      end
+
+      it do
+        player.put_disk(:d, 3)
+        player.put_disk(:e, 3, false)
+        expect(player.next_moves[1][:openness]).to eq 8
+        expect(player.next_moves[1][:result]).to eq [[:e, 3], [:e, 4]]
+      end
+    end
+
+    context "when the first argument is `false`" do
+      it do
+        ans = [[:c, 5], [:d, 6], [:e, 3], [:f, 4]]
+        expect(player.next_moves(false).map{ |move| move[:move] }).to eq ans
+      end
+
+      it do
+        player.put_disk(:d, 3)
+        player.put_disk(:e, 3, false)
+        expect(player.next_moves(false)[0][:openness]).to eq 5
+        expect(player.next_moves(false)[0][:result]).to eq [[:d, 3]]
+      end
+    end
+  end
+
+  describe "#count_disks" do
+    context "when the first argument is omitted" do
+      it do
+        board.put_disk(:a, 1, :black)
+        expect(player.count_disks).to eq 3
+      end
+    end
+
+    context "when the first argument is `false`" do
+      it do
+        board.put_disk(:a, 1, :black)
+        expect(player.count_disks(false)).to eq 2
+      end
+    end
+  end
+
+  describe "#status" do
+    it { expect(player.status[:mine]).to eq [[:d, 5], [:e, 4]] }
+    it { expect(player.status[:opponent]).to eq [[:d, 4], [:e, 5]] }
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Reversi::Board do
+  let(:options) do
+    {:player_b => Reversi::Player::RandomAI,
+     :player_w => Reversi::Player::RandomAI,
+     :disk_b => "b",
+     :disk_w => "w",
+     :disk_color_b => disk_color_b,
+     :disk_color_w => disk_color_w,
+     :progress => false,
+     :stack_limit => 3}
+  end
+  let(:board) { Reversi::Board.new(options) }
+
+  describe "sets each disk color" do
+    context "when a color name is valid" do
+      let(:disk_color_b) { "cyan" }
+      let(:disk_color_w) { :red }
+      it "sets the valid color value" do
+        expect(board.options[:disk_color_b]).to eq 36
+        expect(board.options[:disk_color_w]).to eq 31
+      end
+    end
+
+    context "when a color name is invalid" do
+      let(:disk_color_b) { "hoge" }
+      let(:disk_color_w) { :hoge }
+      it "sets 0" do
+        expect(board.options[:disk_color_b]).to eq 0
+        expect(board.options[:disk_color_w]).to eq 0
+      end
+    end
+  end
+
+  describe "#push_stack" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+
+    it "the stack size limit is 3(default)" do
+      4.times { board.push_stack }
+      expect(board.stack.size).to eq 3
+    end
+
+    it "the deep copy operation is used" do
+      board.push_stack
+      board.put_disk(:a, 1, :black)
+      board.push_stack
+      expect(board.stack[0]).not_to eq board.stack[1]
+    end
+  end
+
+  describe "#undo!" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+
+    context "when the first argument is omitted" do
+      it "the default value is 1" do
+        3.times { board.push_stack }
+        expect{ board.undo! }.to change{ board.stack.size }.by(-1)
+      end
+    end
+
+    context "when the first argument is supplied" do
+      it "the number is used" do
+        3.times { board.push_stack }
+        expect{ board.undo! 2 }.to change{ board.stack.size }.by(-2)
+      end
+    end
+  end
+
+  describe "#status" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+    it "returns a hash containing the coordinates of each color" do
+      expect{ board.put_disk(:a, 1, :black) }.to change{ board.status[:black].size }.by(1)
+      expect{ board.put_disk(:b, 1, :black) }.to change{ board.status[:none].size }.by(-1)
+    end
+  end
+
+  describe "#openness" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+    it "returns the openness of the coordinates" do
+      expect(board.openness(:a, 1)).to eq 3
+      expect(board.openness(:b, 2)).to eq 8
+      expect(board.openness(:d, 4)).to eq 5
+    end
+  end
+
+  describe "#at" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+
+    context "when the first argument is a number" do
+      it do
+        board.put_disk(:c, 3, :white)
+        expect(board.at(3, 3)).to eq :white
+      end
+    end
+
+    context "when the first argument is a symbol" do
+      it do
+        board.put_disk(7, 8, :black)
+        expect(board.at(:g, 8)).to eq :black
+      end
+    end
+  end
+
+  describe "#count_disks" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+    it { expect(board.count_disks(:black)).to eq 2 }
+    it { expect(board.count_disks(:white)).to eq 2 }
+    it { expect(board.count_disks(:none)).to eq 60 }
+  end
+
+  describe "#next_moves" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+    it { expect(board.next_moves(:black)).to eq [[:c, 4], [:d, 3], [:e, 6], [:f, 5]] }
+    it { expect(board.next_moves(:white)).to eq [[:c, 5], [:d, 6], [:e, 3], [:f, 4]] }
+  end
+
+  describe "#put_disk, #flip_disks" do
+    let(:disk_color_b) { 0 }
+    let(:disk_color_w) { 0 }
+    it "flips the opponent's disks between a new disk and another disk of my color" do
+      board.put_disk(:d, 6, :white)
+      board.put_disk(:e, 3, :white)
+      board.put_disk(:f, 3, :black)
+      board.put_disk(:d, 3, :black)
+      expect{ board.flip_disks(:d, 3, :black) }.to change{ board.status[:black].size }.by(2)
+    end
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Reversi::Game do
+  describe "next moves" do
+    before do
+      @game = Reversi::Game.new
+      @game.board.put_disk(6, 3, :black)
+      @game.board.put_disk(6, 5, :black)
+      @game.board.put_disk(6, 6, :black)
+      @game.board.put_disk(6, 7, :white)
+      @game.board.put_disk(7, 4, :black)
+      @game.board.put_disk(8, 4, :black)
+    end
+
+    context "before `player_w` places a piece on position [f4]" do
+      it do
+        ans = [[:c, 5], [:d, 6], [:e, 3], [:f, 4], [:g, 5], [:g, 7]]
+        expect(@game.player_w.next_moves.map{ |move| move[:move] }).to eq ans
+      end
+      it { expect(@game.player_w.count_disks).to eq 3 }
+      it { expect(@game.player_b.count_disks).to eq 7 }
+    end
+
+    context "after `player_w` places a piece on position [f4]" do
+      before do
+        @game.player_w.put_disk(:f, 4)
+      end
+      it do
+        ans = [[:c, 5], [:c, 6], [:d, 6], [:f, 2], [:g, 2], [:h, 3]]
+        expect(@game.player_w.next_moves.map{ |move| move[:move] }).to eq ans
+      end
+      it { expect(@game.player_w.count_disks).to eq 7 }
+      it { expect(@game.player_b.count_disks).to eq 4 }
+    end
+  end
+
+  describe "from a record of a reversi game" do
+    game = Reversi::Game.new
+    game.player_b.put_disk(:c, 4); game.player_w.put_disk(:e, 3)
+    game.player_b.put_disk(:f, 6); game.player_w.put_disk(:e, 6)
+    game.player_b.put_disk(:f, 5); game.player_w.put_disk(:c, 5)
+    game.player_b.put_disk(:f, 4); game.player_w.put_disk(:g, 6)
+    game.player_b.put_disk(:f, 7); game.player_w.put_disk(:d, 3)
+    game.player_b.put_disk(:f, 3); game.player_w.put_disk(:g, 5)
+    game.player_b.put_disk(:g, 4); game.player_w.put_disk(:e, 7)
+    game.player_b.put_disk(:d, 6); game.player_w.put_disk(:h, 3)
+    game.player_b.put_disk(:f, 8); game.player_w.put_disk(:g, 3)
+    game.player_b.put_disk(:c, 6); game.player_w.put_disk(:c, 3)
+    game.player_b.put_disk(:c, 2); game.player_w.put_disk(:d, 7)
+    game.player_b.put_disk(:e, 8); game.player_w.put_disk(:c, 8)
+    game.player_b.put_disk(:h, 4); game.player_w.put_disk(:h, 5)
+    game.player_b.put_disk(:d, 2); game.player_w.put_disk(:d, 8)
+    game.player_b.put_disk(:b, 8); game.player_w.put_disk(:b, 3)
+    game.player_b.put_disk(:c, 7); game.player_w.put_disk(:e, 2)
+    game.player_b.put_disk(:a, 4); game.player_w.put_disk(:d, 1)
+    game.player_b.put_disk(:c, 1); game.player_w.put_disk(:f, 2)
+    game.player_b.put_disk(:e, 1); game.player_w.put_disk(:f, 1)
+    game.player_b.put_disk(:g, 1); game.player_w.put_disk(:a, 3)
+    game.player_b.put_disk(:b, 5); game.player_w.put_disk(:b, 4)
+    game.player_b.put_disk(:a, 5); game.player_w.put_disk(:a, 6)
+    game.player_b.put_disk(:b, 6); game.player_w.put_disk(:a, 7)
+    game.player_b.put_disk(:g, 2); game.player_w.put_disk(:h, 1)
+    game.player_b.put_disk(:b, 2); game.player_w.put_disk(:b, 7)
+    game.player_b.put_disk(:h, 2); game.player_w.put_disk(:g, 7)
+    game.player_b.put_disk(:a, 8); game.player_w.put_disk(:a, 2)
+    game.player_b.put_disk(:h, 7); game.player_w.put_disk(:h, 6)
+    game.player_b.put_disk(:a, 1); game.player_w.put_disk(:b, 1)
+                                   game.player_w.put_disk(:g, 8)
+    game.player_b.put_disk(:h, 8)
+    ans = [
+      [2,  2,  2,  2,  2,  2,  2,  2,  2, 2],
+      [2, -1, -1, -1, -1, -1, -1, -1, -1, 2],
+      [2,  1,  1,  1, -1, -1,  1, -1, -1, 2],
+      [2,  1,  1, -1,  1,  1, -1, -1, -1, 2],
+      [2,  1, -1,  1,  1, -1, -1, -1, -1, 2],
+      [2,  1, -1, -1,  1, -1,  1, -1, -1, 2],
+      [2,  1, -1, -1, -1,  1, -1,  1, -1, 2],
+      [2,  1, -1, -1,  1,  1,  1, -1, -1, 2],
+      [2,  1, -1,  1,  1,  1,  1, -1, -1, 2],
+      [2,  2,  2,  2,  2,  2,  2,  2,  2, 2]
+    ]
+    it { expect(game.board.columns).to eq ans }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reversi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - seinosuke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,40 +24,38 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-description: A reversi game program.
-email:
-- seinosuke.3606@gmail.com
+description: |
+  A Ruby Gem to play reversi game. You can enjoy a game on the command line
+  or easily make your original reversi game programs.
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- images/reversi.gif
 - lib/reversi.rb
+- lib/reversi/board.rb
+- lib/reversi/configuration.rb
+- lib/reversi/game.rb
+- lib/reversi/player.rb
+- lib/reversi/player/base_player.rb
+- lib/reversi/player/human.rb
+- lib/reversi/player/negamax_ai.rb
+- lib/reversi/player/random_ai.rb
 - lib/reversi/version.rb
 - reversi.gemspec
-- spec/reversi_spec.rb
+- spec/base_player_spec.rb
+- spec/board_spec.rb
+- spec/game_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/seinosuke/reversi
 licenses:
 - MIT
 metadata: {}
@@ -69,7 +67,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -77,11 +75,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Reversi
+summary: A Ruby Gem to play reversi game.
 test_files:
-- spec/reversi_spec.rb
+- spec/base_player_spec.rb
+- spec/board_spec.rb
+- spec/game_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/.travis.yml

@@ -1,3 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.0

data/spec/reversi_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Reversi do
-  it 'has a version number' do
-    expect(Reversi::VERSION).not_to be nil
-  end
-
-  it 'does something useful' do
-    expect(false).to eq(true)
-  end
-end