reversi 1.0.2 → 2.0.0

data/lib/reversi/player/base_player.rb

@@ -5,7 +5,9 @@ module Reversi::Player
     # Initializes a new BasePlayer object.
     def initialize(color, board)
       @my_color = color
-      @opponent_color = (@my_color == :white ? :black : :white)
+      @opponent_color = 
+        @my_color == Reversi::Board::DISK[:white] ? 
+        Reversi::Board::DISK[:black] : Reversi::Board::DISK[:white]
       @board = board
     end
 
@@ -22,9 +24,7 @@ module Reversi::Player
     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
-      flip_disks(x, y, color)
-      @board.put_disk(x, y, color)
+      @board.flip_disks(x, y, color)
     end
 
     # Returns an array of the next moves.
@@ -33,13 +33,7 @@ module Reversi::Player
     # @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
+      @board.next_moves(color)
     end
 
     # Returns a number of the supplied color's disks.
@@ -47,7 +41,8 @@ module Reversi::Player
     # @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)
+      color = my_color ? @my_color : @opponent_color
+      @board.count_disks(color)
     end
 
     # Returns a hash containing the coordinates of each color.
@@ -55,19 +50,10 @@ module Reversi::Player
     # @return [Hash{Symbol => Array<Symbol, Integer>}]
     def status
       convert = {
-        :black => @my_color == :black ? :mine : :opponent,
-        :white => @my_color == :white ? :mine : :opponent,
+        :black => @my_color == Reversi::Board::DISK[:black] ? :mine : :opponent,
+        :white => @my_color == Reversi::Board::DISK[: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

@@ -1,6 +1,15 @@
 module Reversi::Player
   class Human < BasePlayer
 
+    def initialize(color, _board)
+      super
+
+      case color
+      when Reversi::Board::DISK[:black] then @color = :black
+      when Reversi::Board::DISK[:white] then @color = :white
+      end
+    end
+
     def move(board)
       return if next_moves.empty?
       puts board.to_s
@@ -14,7 +23,7 @@ module Reversi::Player
 
     def input_move
       loop do
-        print "#{@my_color}: "
+        print "#{@color}: "
         @input_move = gets.chomp.split("")
         exit if [['q'], ['e','x','i','t']].include? @input_move
         redo if check_size == :redo
@@ -40,7 +49,7 @@ module Reversi::Player
     end
 
     def check_valid
-      unless next_moves.map{ |v| v[:move] }.include?(@input_move)
+      unless next_moves.include?(@input_move)
         return :redo
       end
       :valid

data/lib/reversi/player/min_max_ai.rb

@@ -19,7 +19,7 @@ module Reversi::Player
     end
 
     def move(board)
-      moves = next_moves.map{ |v| v[:move] }
+      moves = next_moves
       return if moves.empty?
       next_move = moves.map do |move|
         { :move => move, :point => evaluate(move, board, 3, true) }
@@ -29,7 +29,7 @@ module Reversi::Player
 
     def evaluate(move, board, depth, color)
       put_disk(*move, color)
-      moves = next_moves(!color).map{ |v| v[:move] }
+      moves = next_moves(!color)
 
       if depth == 1
         status[:mine].inject(0){ |sum, xy| sum + @evaluation_value[xy] }

data/lib/reversi/player/nega_max_ai.rb

@@ -19,7 +19,7 @@ module Reversi::Player
     end
 
     def move(board)
-      moves = next_moves.map{ |v| v[:move] }
+      moves = next_moves
       return if moves.empty?
       next_move = moves.map do |move|
         { :move => move, :point => evaluate(move, board, 3, true) }
@@ -29,7 +29,7 @@ module Reversi::Player
 
     def evaluate(move, board, depth, color)
       put_disk(*move, color)
-      moves = next_moves(!color).map{ |v| v[:move] }
+      moves = next_moves(!color)
 
       if depth == 1
         status[:mine].inject(0){ |sum, xy| sum + @evaluation_value[xy] }

data/lib/reversi/player/random_ai.rb

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

data/lib/reversi/version.rb

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

data/spec/base_player_spec.rb

@@ -8,13 +8,13 @@ describe Reversi::Player::BasePlayer do
   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)
+        expect{ player.put_disk(4, 3) }.to change{ board.status[:black].size }.by(2)
       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)
+        expect{ player.put_disk(5, 3, false) }.to change{ board.status[:white].size }.by(2)
       end
     end
   end
@@ -22,29 +22,15 @@ describe Reversi::Player::BasePlayer do
   describe "#next_moves" do
     context "when the first argument is omitted" do
       it do
-        ans = [[3, 4], [4, 3], [5, 6], [6, 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 [[5, 3], [5, 4]]
+        ans = [[5, 6], [6, 5], [3, 4], [4, 3]]
+        expect(player.next_moves).to eq ans
       end
     end
 
     context "when the first argument is `false`" do
       it do
-        ans = [[3, 5], [4, 6], [5, 3], [6, 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 [[4, 3]]
+        ans = [[4, 6], [3, 5], [6, 4], [5, 3]]
+        expect(player.next_moves(false)).to eq ans
       end
     end
   end
@@ -52,14 +38,14 @@ describe Reversi::Player::BasePlayer do
   describe "#count_disks" do
     context "when the first argument is omitted" do
       it do
-        board.put_disk(:a, 1, :black)
+        board.put_disk(1, 1, Reversi::Board::DISK[: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)
+        board.put_disk(1, 1, Reversi::Board::DISK[:black])
         expect(player.count_disks(false)).to eq 2
       end
     end
@@ -67,6 +53,6 @@ describe Reversi::Player::BasePlayer do
 
   describe "#status" do
     it { expect(player.status[:mine]).to eq [[4, 5], [5, 4]] }
-    it { expect(player.status[:opponent]).to eq [[4, 4], [5, 5]] }
+    it { expect(player.status[:opponent]).to eq [[5, 5], [4, 4]] }
   end
 end

data/spec/board_spec.rb

@@ -8,8 +8,8 @@ describe Reversi::Board do
      :disk_w => "w",
      :disk_color_b => disk_color_b,
      :disk_color_w => disk_color_w,
-     :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}
   end
@@ -75,7 +75,7 @@ describe Reversi::Board do
 
     it "the deep copy operation is used" do
       board.push_stack
-      board.put_disk(:a, 1, :black)
+      board.put_disk(1, 1, Reversi::Board::DISK[:black])
       board.push_stack
       expect(board.stack[0]).not_to eq board.stack[1]
     end
@@ -97,8 +97,10 @@ describe Reversi::Board 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)
+      expect{ board.put_disk(1, 1, Reversi::Board::DISK[:black]) }
+        .to change{ board.status[:black].size }.by(1)
+      expect{ board.put_disk(2, 1, Reversi::Board::DISK[:black]) }
+        .to change{ board.status[:none].size }.by(-1)
     end
   end
 
@@ -106,9 +108,9 @@ describe Reversi::Board 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
+      expect(board.openness(1, 1)).to eq 3
+      expect(board.openness(2, 2)).to eq 8
+      expect(board.openness(4, 4)).to eq 5
     end
   end
 
@@ -116,45 +118,40 @@ describe Reversi::Board 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
+    it do
+      board.put_disk(3, 3, Reversi::Board::DISK[:white])
+      expect(board.at(3, 3)).to eq :white
+      expect(board.at(1, 1)).to eq :none
+      expect(board.at(4, 5)).to eq :black
     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 }
+    it { expect(board.count_disks(Reversi::Board::DISK[:black])).to eq 2 }
+    it { expect(board.count_disks(Reversi::Board::DISK[:white])).to eq 2 }
+    it { expect(board.count_disks(Reversi::Board::DISK[: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 [[3, 4], [4, 3], [5, 6], [6, 5]] }
-    it { expect(board.next_moves(:white)).to eq [[3, 5], [4, 6], [5, 3], [6, 4]] }
+    it { expect(board.next_moves(Reversi::Board::DISK[:black]))
+      .to eq [[5, 6], [6, 5], [3, 4], [4, 3]] }
+    it { expect(board.next_moves(Reversi::Board::DISK[:white]))
+      .to eq [[4, 6], [3, 5], [6, 4], [5, 3]] }
   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)
+      board.put_disk(4, 6, Reversi::Board::DISK[:white])
+      board.put_disk(5, 3, Reversi::Board::DISK[:white])
+      board.put_disk(6, 3, Reversi::Board::DISK[:black])
+      expect{ board.flip_disks(4, 3, Reversi::Board::DISK[:black]) }
+        .to change{ board.status[:black].size }.by(3)
     end
   end
 end

data/spec/game_spec.rb

@@ -4,18 +4,18 @@ 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)
+      @game.board.put_disk(6, 3, Reversi::Board::DISK[:black])
+      @game.board.put_disk(6, 5, Reversi::Board::DISK[:black])
+      @game.board.put_disk(6, 6, Reversi::Board::DISK[:black])
+      @game.board.put_disk(6, 7, Reversi::Board::DISK[:white])
+      @game.board.put_disk(7, 4, Reversi::Board::DISK[:black])
+      @game.board.put_disk(8, 4, Reversi::Board::DISK[:black])
     end
 
     context "before `player_w` places a piece on position [f4]" do
       it do
-        ans = [[3, 5], [4, 6], [5, 3], [6, 4], [7, 5], [7, 7]]
-        expect(@game.player_w.next_moves.map{ |move| move[:move] }).to eq ans
+        ans = [[7, 7], [4, 6], [7, 5], [3, 5], [6, 4], [5, 3]]
+        expect(@game.player_w.next_moves).to eq ans
       end
       it { expect(@game.player_w.count_disks).to eq 3 }
       it { expect(@game.player_b.count_disks).to eq 7 }
@@ -23,11 +23,11 @@ describe Reversi::Game do
 
     context "after `player_w` places a piece on position [f4]" do
       before do
-        @game.player_w.put_disk(:f, 4)
+        @game.player_w.put_disk(6, 4)
       end
       it do
-        ans = [[3, 5], [3, 6], [4, 6], [6, 2], [7, 2], [8, 3]]
-        expect(@game.player_w.next_moves.map{ |move| move[:move] }).to eq ans
+        ans = [[4, 6], [3, 6], [3, 5], [8, 3], [7, 2], [6, 2]]
+        expect(@game.player_w.next_moves).to eq ans
       end
       it { expect(@game.player_w.count_disks).to eq 7 }
       it { expect(@game.player_b.count_disks).to eq 4 }
@@ -37,17 +37,17 @@ describe Reversi::Game do
   describe "initial position" do
     it "default" do
       game = Reversi::Game.new
-      expect(game.board.at(:e, 4)).to eq :black
-      expect(game.board.at(:d, 4)).to eq :white
+      expect(game.board.at(5, 4)).to eq :black
+      expect(game.board.at(4, 4)).to eq :white
     end
 
     it "original position" do
-      initial = {:black => [[:a, 1]], :white => [[:h, 8]]}
+      initial = {:black => [[1, 1]], :white => [[8, 8]]}
       options = {:initial_position => initial}
       game = Reversi::Game.new(options)
-      expect(game.board.at(:d, 4)).to eq :none
-      expect(game.board.at(:a, 1)).to eq :black
-      expect(game.board.at(:h, 8)).to eq :white
+      expect(game.board.at(4, 4)).to eq :none
+      expect(game.board.at(1, 1)).to eq :black
+      expect(game.board.at(8, 8)).to eq :white
     end
   end
 
@@ -65,49 +65,44 @@ describe Reversi::Game do
 
   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 }
+    game.player_b.put_disk(3, 4); game.player_w.put_disk(5, 3)
+    game.player_b.put_disk(6, 6); game.player_w.put_disk(5, 6)
+    game.player_b.put_disk(6, 5); game.player_w.put_disk(3, 5)
+    game.player_b.put_disk(6, 4); game.player_w.put_disk(7, 6)
+    game.player_b.put_disk(6, 7); game.player_w.put_disk(4, 3)
+    game.player_b.put_disk(6, 3); game.player_w.put_disk(7, 5)
+    game.player_b.put_disk(7, 4); game.player_w.put_disk(5, 7)
+    game.player_b.put_disk(4, 6); game.player_w.put_disk(8, 3)
+    game.player_b.put_disk(6, 8); game.player_w.put_disk(7, 3)
+    game.player_b.put_disk(3, 6); game.player_w.put_disk(3, 3)
+    game.player_b.put_disk(3, 2); game.player_w.put_disk(4, 7)
+    game.player_b.put_disk(5, 8); game.player_w.put_disk(3, 8)
+    game.player_b.put_disk(8, 4); game.player_w.put_disk(8, 5)
+    game.player_b.put_disk(4, 2); game.player_w.put_disk(4, 8)
+    game.player_b.put_disk(2, 8); game.player_w.put_disk(2, 3)
+    game.player_b.put_disk(3, 7); game.player_w.put_disk(5, 2)
+    game.player_b.put_disk(1, 4); game.player_w.put_disk(4, 1)
+    game.player_b.put_disk(3, 1); game.player_w.put_disk(6, 2)
+    game.player_b.put_disk(5, 1); game.player_w.put_disk(6, 1)
+    game.player_b.put_disk(7, 1); game.player_w.put_disk(1, 3)
+    game.player_b.put_disk(2, 5); game.player_w.put_disk(2, 4)
+    game.player_b.put_disk(1, 5); game.player_w.put_disk(1, 6)
+    game.player_b.put_disk(2, 6); game.player_w.put_disk(1, 7)
+    game.player_b.put_disk(7, 2); game.player_w.put_disk(8, 1)
+    game.player_b.put_disk(2, 2); game.player_w.put_disk(2, 7)
+    game.player_b.put_disk(8, 2); game.player_w.put_disk(7, 7)
+    game.player_b.put_disk(1, 8); game.player_w.put_disk(1, 2)
+    game.player_b.put_disk(8, 7); game.player_w.put_disk(8, 6)
+    game.player_b.put_disk(1, 1); game.player_w.put_disk(2, 1)
+                                  game.player_w.put_disk(7, 8)
+    game.player_b.put_disk(8, 8)
+    ans = {
+      :black =>0x809F_AEC4_D8B4_FBFF,
+      :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]
+    end
   end
 end

data/spec/player_spec.rb

@@ -2,27 +2,27 @@ require 'spec_helper'
 
 class ValidPlayer < Reversi::Player::BasePlayer
   def move(board)
-    moves = next_moves.map{ |v| v[:move] }
+    moves = next_moves
     put_disk(*moves.sample) unless moves.empty?
   end
 end
 
 class InvalidPlayer1 < Reversi::Player::BasePlayer
   def move(board)
-    put_disk(:a, 1)
+    put_disk(1, 1)
   end
 end
 
 class InvalidPlayer2 < Reversi::Player::BasePlayer
   def move(board)
-    put_disk(:d, 4)
+    put_disk(4, 4)
   end
 end
 
 class InvalidPlayer3 < Reversi::Player::BasePlayer
   def move(board)
-    put_disk(:a, 1)
-    put_disk(:a, 2)
+    put_disk(1, 1)
+    put_disk(1, 2)
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reversi
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - seinosuke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-17 00:00:00.000000000 Z
+date: 2015-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -41,6 +41,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- black
+- ext/reversi/bit_board_functions.c
+- ext/reversi/bit_board_functions.h
+- ext/reversi/board.c
+- ext/reversi/board.h
 - ext/reversi/extconf.rb
 - ext/reversi/reversi.c
 - ext/reversi/reversi.h
@@ -63,6 +68,7 @@ files:
 - spec/game_spec.rb
 - spec/player_spec.rb
 - spec/spec_helper.rb
+- white
 homepage: https://github.com/seinosuke/reversi
 licenses:
 - MIT