sea_battle 0.1.1 → 0.1.3

data/README.md

@@ -18,55 +18,80 @@ Or install it yourself as:
 
 ## Usage
 
-Initialize board of the game
+### Initialize board of the game
 
     $ require "sea_battle"
 
     $ board = SeaBattle::Board.new.board
     $ board[0][3].is_attacked?
 
-Add random ship on the board
+### Add random ship on the board
 
     $ require "random_ship"
     ...
 
     SeaBattle::RandomBoard.new(board, 3).add_ship
 
-Play on console
-
-    $ sea_battle
-
-    #=>             SEA BATTLE
-
-    #=>        A   B   C   D   E   F   G   H   I   J           A   B   C   D   E   F   G   H   I   J
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   0  │   │   │   │   │   │   │   │ ◯ │   │   │    0  │   │   │   │   │   │   │   │   │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   1  │ ◯ │   │   │   │   │   │   │   │   │ ◯ │    1  │   │   │   │   │   │   │   │   │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   2  │ ◯ │   │   │   │   │   │   │   │   │ ◯ │    2  │   │   │   │   │   │   │ • │ • │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   3  │ ◯ │   │ ⬤ │ ⬤ │   │   │   │   │   │   │    3  │   │   │   │   │   │   │   │ • │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   4  │ ⬤ │   │   │   │   │ ◯ │   │   │   │   │    4  │   │   │   │   │   │ • │   │   │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   5  │   │   │ ◯ │   │   │ ◯ │   │   │   │ ◯ │    5  │   │   │   │   │   │   │   │   │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   6  │ ◯ │   │   │   │   │   │   │ ◯ │   │   │    6  │   │   │   │   │   │   │   │   │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   7  │   │   │ ◯ │   │   │   │   │ ◯ │   │   │    7  │   │   │   │   │   │   │   │   │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   8  │   │   │ ◯ │   │   │   │   │ ◯ │   │   │    8  │   │   │   │   │   │   │   │   │   │   │
-    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
-    #=>   9  │   │   │ ◯ │   │   │   │   │   │   │   │    9  │   │   │   │   │   │   │   │   │   │   │
-
-    #=>   4a, ... - select part of ship
-    #=>   (e)xit of game
-
-Use class SeaBattle
+### Use class SeaBattle
 
    $ require "sea_battle"
 
    $ first_board = SeaBattle::Board.new
    $ second_board = SeaBattle::Board.new
-   $ SeaBattle.new(first_board, second_board)
+   $ sea_battle = SeaBattle.new(first_board, second_board)
+
+#### Game is activated?
+   $ sea_battle.is_activated?
+
+#### You can get which player is active
+   $ sea_battle.active_user #=> :first_player
+
+#### Ship on position row, column is sunken?
+   $ sea_battle.is_sunken_ship?(3, 7) #=> false
+
+#### You can attack position (row, column)
+   $ sea_battle.move(:second_player, :attack, 2, 9)
+
+#### When game is over you can see winner
+   $ sea_battle.winner_is #=> :first_player
+
+### Play on console (min 92x40)
+
+    $ sea_battle
+
+    #=>               SEA BATTLE
+
+    #=>        A   B   C   D   E   F   G   H   I   J         A   B   C   D   E   F   G   H   I   J
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    0 │ □ │   │   │   │   │   │   │   │   │ □ │   0 │   │   │   │   │   │   │   │   │   │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    1 │ □ │   │ □ │   │ □ │   │   │ ⬤/│   │ □ │   1 │   │   │   │   │   │ • │ ⬤/│   │   │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    2 │ □ │   │   │   │ ■ │   │   │   │   │ □ │   2 │   │   │   │   │   │   │ ⬤/│ • │ • │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    3 │ □ │ • │   │   │ □ │ • │ • │   │   │   │   3 │ • │   │   │   │   │   │ ⬤/│ • │ • │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    4 │   │   │ • │   │   │   │   │ □ │   │   │   4 │   │   │   │ ⬤/│ ⬤/│   │   │   │ • │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    5 │   │ • │   │   │   │   │   │ □ │   │   │   5 │   │   │   │   │   │   │   │ • │ ⬤/│   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    6 │   │   │ • │   │   │ • │   │   │ • │ • │   6 │   │   │   │   │   │   │ • │   │ • │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    7 │   │   │   │ • │   │   │   │ • │ ■ │   │   7 │   │   │   │   │   │   │   │   │   │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    8 │ ⬤ │   │   │ • │   │   │ □ │   │ □ │   │   8 │   │ • │   │ • │ ⬤/│ • │   │   │   │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+    #=>    9 │ ⬤ │   │   │   │ □ │   │   │   │   │ • │   9 │   │   │   │   │ • │   │   │   │   │   │
+    #=>      ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼     ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼
+
+    #=>     09:49:09 Computer: Moved on position 6j
+    #=>     09:49:11 You: Moved on position 9e
+    #=>     09:49:13 Computer: Moved on position 3b
+    #=>     09:49:15 You: Used incorrect command: a
+    #=>   ____________________________________________________________
+    #=>   ⬤/ - sunk ship; ■ - hit ship; □ - selected ship; • - mishit
+
+    #=>   (r)andom position into attack
+    #=>   4a, 8i, ... - select part of ship
+    #=>   (e)xit of game
+    #=>   #=>

data/lib/sea_battle/board.rb

@@ -2,37 +2,77 @@
 
 require_relative "cell"
 require_relative "random_ship"
+require_relative "support"
 
 class SeaBattle
   # It's Board of game Sea Battle
   class Board
+    include ::SeaBattle::Support
 
     attr_reader :board, :vertical, :horizontal, :status
 
     def initialize(board = "1" * 100, status = :initialized)
-      @board = board.split("").map do |status|
-        Cell.new(status.to_i)
-      end.each_slice(10).to_a
-      @horizontal = 10
-      @vertical = 10
+      @horizontal, @vertical = 10, 10
+
+      load_board(board)
 
       @status = status
-      @quantity_ships = {1 => 4, 2 => 3, 3 => 2, 4 => 1}
       check_board
     end
 
-    def activated_board
+    # When all ships are on board then board can be activated
+    # Return true when board was activated
+    def activate_board
+      result = 0
+      @board.flatten.each do |cell|
+        result += 1 if cell.is_in_ship?
+      end
+      return false unless result == 20
       @status = :activated
+      true
     end
 
     def attack(row, column)
-      board[row][column].attack
+      if @status == :activated
+        board[row][column].attack
+        is_sunken_ship?(row, column)
+        is_finished?
+      end
+    end
+
+    def is_attacked?(row, column)
+      board[row][column].is_attacked?
     end
 
     def is_in_ship?(row, column)
       board[row][column].is_in_ship?
     end
 
+    # Return true if on position (row, column) is the ship which is sunked
+    # Return false if on position (row, column) is not the ship which is sunked
+    # or don't exist the ship
+    def is_sunken_ship?(row, column)
+      positions = ship_positions(row, column)
+      return false if positions.empty?
+      is_sunk = true
+      positions.each do |position_row, position_column|
+        is_sunk = false unless board[position_row][position_column].is_attacked?
+      end
+      if is_sunk
+        positions.each do |position_row, position_column|
+          board[position_row][position_column].sunk
+        end
+      end
+      is_sunk
+    end
+
+    # Return position to attack (have not attacked)
+    def random_position
+      mixed_board_positions.each do |row, column|
+        return [row, column] unless is_attacked?(row, column)
+      end
+    end
+
     # Set ships on the board (random positions)
     def random_ships
       return unless @status == :initialized
@@ -57,6 +97,17 @@ class SeaBattle
       raise "The board is not Array class" unless @board.size == 10
     end
 
+    def is_finished?
+      is_finished = true
+      board.each do |line|
+        line.each do |cell|
+          is_finished = false if cell.is_in_ship? and not cell.is_sunk?
+        end
+      end
+      @status = :finished if is_finished
+      is_finished
+    end
+
     # it should return array of ship position
     # for horizontal line with position [row, column]
     def horizontal_ship_position(row, column)
@@ -72,6 +123,12 @@ class SeaBattle
       result
     end
 
+    def load_board(board)
+      @board = board.split("").map do |status|
+        Cell.new(status.to_i)
+      end.each_slice(10).to_a
+    end
+
     def reset_board
       board.each do |line|
         line.each do |cell|

data/lib/sea_battle/cell.rb

@@ -11,6 +11,7 @@ class SeaBattle
     # 2 -> field is part of ship
     # 4 -> attacked field
     # 8 -> is only selected by user
+    #16 -> is sunk
     # 6 -> attacked field and exsist ship
     def initialize(status = 1)
       @status = status
@@ -24,6 +25,10 @@ class SeaBattle
       @status += 4 unless is_attacked?
     end
 
+    def sunk
+      @status += 16 unless is_sunk?
+    end
+
     def switch_select
       is_selected? ? @status -= 8 : @status += 8
     end
@@ -44,6 +49,10 @@ class SeaBattle
       @status & 8 == 8
     end
 
+    def is_sunk?
+      @status & 16 == 16
+    end
+
     def reset_cell
       @status = 1
     end

data/lib/sea_battle/gui.rb

@@ -12,26 +12,26 @@ class SeaBattle
       @user_board = ::SeaBattle::Board.new
       @computer_board = ::SeaBattle::Board.new
       @computer_board.random_ships
-      @computer_board.activated_board
+      @computer_board.activate_board
       @sea_battle = ::SeaBattle.new(@user_board, @computer_board)
       set_default_keyboard
+      push_message("Initialized SeaBattle")
     end
 
     def play
       while true and not @keyboard[:exit]
-        system "clear"
-        show_boards
-        get_input
+        update_screen
+        user_command
+        next if @keyboard[:error]
         if @keyboard[:position]
-          @sea_battle.move(:first_player, :attack, @row, @column)
-          system "clear"
-          show_boards
+          attack_on(@row, @column, :first_player)
+          break unless @sea_battle.winner_is.nil?
           while @sea_battle.active_user == :second_player
             sleep 1 + rand
-            @sea_battle.move(:second_player, :attack, rand(10), rand(10))
-            system "clear"
-            show_boards
+            row, column = @computer_board.random_position
+            attack_on(row, column, :second_player)
           end
+          break unless @sea_battle.winner_is.nil?
           @keyboard[:position] = false
         end
       end
@@ -39,73 +39,139 @@ class SeaBattle
 
   private
 
+    def all_positions
+      (0..9).to_a.product(
+        (0..9).to_a.map do |column|
+          (column + 97).chr
+        end
+      ).map { |row, column| "#{row}#{column}" }
+    end
+
+    def attack_on(row, column, active_player)
+      player_name = (active_player == :first_player ? "You" : "Computer")
+      @sea_battle.move(active_player, :attack, row, column)
+      push_message("Moved on position #{row}#{(97 + column).chr}", player_name)
+      if @sea_battle.is_sunken_ship?(row, column, active_player)
+        push_message("Sunk ship", player_name)
+      end
+      if @sea_battle.winner_is == active_player
+        push_message("WIN!!!", player_name)
+      end
+      update_screen
+    end
+
+    def board_line(board, index, player)
+      board.board[index].map do |cell|
+        if cell.is_attacked? and cell.is_in_ship?
+          unless cell.is_sunk?
+            " ■ "
+          else
+            " ⬤ "
+          end
+        elsif cell.is_attacked? and not cell.is_in_ship?
+          " • "
+        elsif not cell.is_attacked? and cell.is_in_ship? and player == :first_player
+          " □ "
+        else
+          " \u205f "
+        end
+      end.join("│")
+    end
+
+    def info_command
+      puts "⬤/ - sunk ship; ■ - hit ship; □ - selected ship; • - mishit"
+      puts ""
+      unless @sea_battle.is_activated?
+        puts "(r)andom your ships on board"
+        puts "(a)ctivate your game if all ships are at properly place"
+      else
+        puts "(r)andom position into attack"
+        puts "4a, 8i, ... - select part of ship"
+      end
+      puts "(e)xit of game"
+      print "#=> "
+    end
+
     def set_default_keyboard
       @keyboard = {
         exit: false,
-        activate: false,
-        position: nil
+        position: nil,
+        error: false
       }
     end
 
-    def show_boards
+    def update_screen
+      system "clear"
       show_title
+      column_position = "A   B   C   D   E   F   G   H   I   J"
+      end_of_board = "┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼"
 
-      puts ""
-      puts "     A   B   C   D   E   F   G   H   I   J           A   B   C   D   E   F   G   H   I   J"
-      @user_board.board.each_with_index do |line, index|
-        user_line = line.map do |cell|
-          if cell.is_attacked? and cell.is_in_ship?
-            " ⬤ "
-          elsif cell.is_attacked? and not cell.is_in_ship?
-            " • "
-          elsif not cell.is_attacked? and cell.is_in_ship?
-            " ◯ "
-          else
-            "   "
-          end
-        end.join("│")
-        computer_line = @computer_board.board[index].map do |cell|
-          if cell.is_attacked? and cell.is_in_ship?
-            " ⬤ "
-          elsif cell.is_attacked? and not cell.is_in_ship?
-            " • "
-          else
-            "   "
-          end
-        end.join("│")
-        puts "   ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼       ┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼"
-        puts "#{index}  │#{user_line}│    #{index}  │#{computer_line}│"
+      puts "     #{column_position}         #{column_position}"
+      (0..9).each do |index|
+        user_line = board_line(@user_board, index, :first_player)
+        computer_line = board_line(@computer_board, index, :second_player)
+        puts "   #{end_of_board}     #{end_of_board}"
+        puts " #{index} │#{user_line}│   #{index} │#{computer_line}│"
       end
+      puts "   #{end_of_board}     #{end_of_board}\n \n"
+      show_messages
     end
 
     def show_title
       puts ""
       puts "#{' '*10}SEA BATTLE ver#{VERSION}"
+      puts ""
     end
 
-    def get_input
-      puts ""
-      puts "4a, ... - select part of ship"
-      unless @keyboard[:activate]
-        puts "(r)andom your ships on board"
-        puts "(a)ctivate your game if all ships are at properly place"
-      end
-      puts "(e)xit of game"
+    def user_command
+      info_command
       keyboard = gets.chomp
       @keyboard[:exit] = true if keyboard == "e"
-      if not @keyboard[:exit] and @keyboard[:activate]
-        @keyboard[:position] = true
-        @row, @column = keyboard.split("")
-        @column = @column.ord - 97
-        @row = @row.to_i
+      if @sea_battle.is_activated?
+        @keyboard[:error] = false
+        if all_positions.include?(keyboard)
+          @row, @column = keyboard.split("")
+          @column = @column.ord - 97
+          @row = @row.to_i
+          @keyboard[:position] = true
+          #if @computer_board.is_attacked?(@row, @column)
+          #  @keyboard[:error] = true
+          #  @keyboard[:position] = false
+          #  push_message("Used incorrect command: #{keyboard}")
+          #end
+        elsif keyboard == "r"
+          @row, @column = @computer_board.random_position
+          @keyboard[:position] = true
+        else
+          @keyboard[:error] = true
+          push_message("Used incorrect command: #{keyboard}")
+        end
+      else
+        if keyboard == "a"
+          if @user_board.activate_board
+            push_message("Activated game")
+          else
+            push_message("Don't activated game!!!")
+          end
+        end
+
+        if keyboard == "r"
+          @user_board.random_ships
+          push_message("Random ships")
+        end
       end
-      if keyboard == "a"
+    end
 
-        @keyboard[:activate] = true
-        @user_board.activated_board
+    def push_message(message, player = "You")
+      @messages ||= []
+      @messages = @messages.rotate(1)
+      @messages[3] = "  #{Time.now.strftime("%H:%M:%S")} #{player}: #{message}"
+    end
 
-      end
-      @user_board.random_ships if keyboard == "r"
+    def show_messages
+      @messages ||= []
+      puts @messages.compact.join("\n")
+      puts "_"*60
     end
 
   end

data/lib/sea_battle/random_ship.rb

@@ -1,9 +1,11 @@
 # encoding: utf-8
 
+require_relative "support"
 
 class SeaBattle
   # It's random positions for new ship
   class RandomShip
+    include ::SeaBattle::Support
 
     def initialize(board, length = 1)
       @board = board.board
@@ -50,13 +52,6 @@ class SeaBattle
       vertical_range.product(horizontal_range)
     end
 
-    def mixed_board_positions
-      offset = Random.rand(@horizontal * @vertical)
-      (0...@vertical).to_a.product(
-        (0...@horizontal).to_a
-      ).rotate(offset)
-    end
-
     def add_ship_of(direct)
       mixed_board_positions.each do |row, column|
         next if direct.eql?(:vertical) and row + @length - 1 >= @vertical

data/lib/sea_battle/support.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+class SeaBattle
+  # Common methods
+  module Support
+
+    def mixed_board_positions
+      offset = Random.rand(@horizontal * @vertical)
+      (0...@vertical).to_a.product(
+        (0...@horizontal).to_a
+      ).rotate(offset)
+    end
+
+  end
+end

data/lib/sea_battle/version.rb

@@ -1,3 +1,3 @@
 class SeaBattle
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/sea_battle.rb

@@ -28,12 +28,26 @@ class SeaBattle
     end
   end
 
+  def is_activated?
+    not first_status.eql?(:initialized) and not second_status.eql?(:initialized)
+  end
+
+  def is_sunken_ship?(row, column, player)
+    if player == :first_player
+      @second_board.is_sunken_ship?(row, column)
+    else
+      @first_board.is_sunken_ship?(row, column)
+    end
+  end
+
   def last_attack_move
     return if @last_attack_move.nil?
     @last_attack_move.join(";")
   end
 
   def move(player, type, row, column)
+    return false unless winner_is.nil?
+
     return false unless [:first_player, :second_player].include?(player)
     return false unless [:choose, :attack, :mark].include?(type)
 
@@ -52,6 +66,12 @@ class SeaBattle
     true
   end
 
+  def winner_is
+    return :second_player if first_status.eql? :finished
+    return :first_player if second_status.eql? :finished
+    nil
+  end
+
   private
 
     def first_status

data/spec/sea_battle/board_spec.rb

@@ -1,10 +1,26 @@
 # encoding: utf-8
 
 require "sea_battle"
+
 describe SeaBattle::Board do
 
   let(:klass) { SeaBattle::Board }
 
+  let(:raw_board) {
+    "1111111121" +
+    "1222211121" +
+    "1111111111" +
+    "1111112112" +
+    "2112112111" +
+    "1111112111" +
+    "1111111111" +
+    "1222111111" +
+    "1111122112" +
+    "1211111112"
+  }
+
+  let(:board) { SeaBattle::Board.new(raw_board) }
+
   it "should properly initialize class" do
     expect { SeaBattle::Board.new }.to_not raise_error
   end
@@ -13,28 +29,28 @@ describe SeaBattle::Board do
     expect { SeaBattle::Board.new("") }.to raise_error
   end
 
+  context "should check method #activate_board" do
+    it "for empty board" do
+      SeaBattle::Board.new.activate_board.should be_false
+    end
+
+    it "for properly arranged ships on board" do
+      SeaBattle::Board.new(raw_board).activate_board.should be_true
+    end
+  end
+
   context "should check method ship_positions"do
 
     it "for non-ship" do
-      board = "0"*100
-      board[2] = "2"
-      board[3] = "2"
-
-      klass.new(board).ship_positions(1, 2).should eq([])
+      board.ship_positions(6, 2).should eq([])
     end
 
     it "for horizontal ship" do
-      board = "1"*100
-      board[2] = "2"
-      board[3] = "2"
-      klass.new(board).ship_positions(0, 2).should eq([[0, 2], [0, 3]])
+      board.ship_positions(7, 2).should eq([[7, 1], [7, 2], [7, 3]])
     end
 
     it "for vertical ship" do
-      board = "0"*100
-      board[23] = "2"
-      board[33] = "2"
-      klass.new(board).ship_positions(2, 3).should eq([[2, 3] ,[3, 3]])
+      board.ship_positions(5, 6).should eq([[3, 6] ,[4, 6], [5, 6]])
     end
 
   end
@@ -52,4 +68,35 @@ describe SeaBattle::Board do
       result.should eq(20)
     end
   end
+
+  context "should check method attack"do
+
+    it "for non-ship" do
+      board.activate_board
+      board.attack(0, 8)
+      board.board[0][8].is_sunk?.should be_false
+      board.attack(1, 8)
+      board.board[0][8].is_sunk?.should be_true
+      board.board[1][8].is_sunk?.should be_true
+    end
+
+  end
+
+  context "should random new position into attack" do
+    let(:active_board) do
+      result = raw_board
+      result[12] = "6"
+      result
+    end
+
+    let(:board) { SeaBattle::Board.new(active_board) }
+
+    it "for simply type" do
+      board.activate_board
+      Random.stub(:rand) { 12 }
+      board.random_position.should eql([1, 3])
+    end
+
+  end
+
 end

data/spec/sea_battle/gui_spec.rb

@@ -35,7 +35,7 @@ describe SeaBattle::GUI do
     gui.stub(:gets).and_return("r", "e")
     reset_content
     gui.play
-    content.should include("◯")
+    content.should include("□")
   end
 
   it "should let user attacked field 2b" do

data/spec/sea_battle_spec.rb

@@ -29,6 +29,7 @@ describe SeaBattle do
     "1111122112" +
     "1211111112"
   }
+
   it "should properly initialize class" do
     expect { SeaBattle.new(board.new, board.new) }.to_not raise_error
   end
@@ -64,7 +65,6 @@ describe SeaBattle do
   end
 
   context "for active game and first player correctly attacked competition ship then" do
-
     let(:board_zero) { board.new(first_raw_board, :activated) }
     let(:board_one) { board.new(first_raw_board, :activated) }
     let(:sea_battle) { SeaBattle.new(board_zero, board_one, "first_player;1;1") }
@@ -85,4 +85,25 @@ describe SeaBattle do
 
   end
 
+  context "for method winer_is" do
+    let(:first_board) { board.new(first_raw_board, :activated) }
+    let(:second_board) { board.new(first_raw_board, :activated) }
+    let(:sea_battle) { SeaBattle.new(first_board, second_board, nil) }
+
+    it "should return nil if no one win of game" do
+      sea_battle.winner_is.should be_nil
+    end
+
+    it "should return :first_player if first player win of game" do
+      first_board.stub(:status) { :finished }
+      sea_battle.winner_is.should eq(:second_player)
+    end
+
+    it "should return :second_player if second player win of game" do
+      second_board.stub(:status) { :finished }
+      sea_battle.winner_is.should eq(:first_player)
+    end
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sea_battle
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-25 00:00:00.000000000 Z
+date: 2013-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,6 +95,7 @@ files:
 - lib/sea_battle/cell.rb
 - lib/sea_battle/gui.rb
 - lib/sea_battle/random_ship.rb
+- lib/sea_battle/support.rb
 - lib/sea_battle/version.rb
 - sea_battle.gemspec
 - spec/sea_battle/board_spec.rb