eat_the_ocean 1.0.0

data/lib/ship.rb

@@ -0,0 +1,126 @@
+module EatTheOcean
+  class Ship
+  	attr_accessor :coordinates, :hits, :size, :sunk, :board_size, :other_ship_array
+
+  	def initialize(other_ship_array = [], board_size = 4)
+  		@other_ship_array = other_ship_array 
+  		@coordinates = []
+  		@size = @coordinates.length
+  		@sunk = 0
+  		@hits = 0
+      @board_size = board_size
+      @sample_array = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"][0..(@board_size - 1)]
+  	end
+
+  	def random_1x2
+      @coordinates[0] = @sample_array.sample + rand(1..@board_size).to_s
+      while @coordinates[0] == ((@sample_array[-1] + (@board_size - 1).to_s) || (@sample_array[-2] + (@board_size).to_s) || (@sample_array[-1] + @board_size.to_s))
+      	@coordinates[0] = @sample_array.sample + rand(1..@board_size).to_s
+      end
+
+      if self.on_bottom_edge?(@coordinates[0],2)
+  			@coordinates [1] = @coordinates[0][0] + @coordinates[0][1].next 
+  		else
+  			@coordinates [1] = @coordinates[0][0].next + @coordinates[0][1]
+  		end
+  		@coordinates
+  	end
+
+    def random_1xSize(size)
+      @coordinates[0] = @sample_array.sample + rand(1..@board_size).to_s
+  		while @other_ship_array.include?(@coordinates[0]) || in_corner?(@coordinates[0], size)
+  			@coordinates[0] = @sample_array.sample + rand(1..@board_size).to_s
+  		end
+     
+      if on_bottom_edge?(@coordinates[0], size)
+        0.upto(size-2) do |x|
+          @coordinates << linear_placer(@coordinates[x], "h")
+        end
+      elsif on_right_edge?(@coordinates[0], size)
+        0.upto(size-2) do |x|
+          @coordinates << linear_placer(@coordinates[x], "v")
+        end
+      else
+        if rand > 0.5
+          0.upto(size-2) do |x|
+           @coordinates << linear_placer(@coordinates[x], "h")
+          end
+        else
+          0.upto(size-2) do |x|
+           @coordinates << linear_placer(@coordinates[x], "v")
+          end
+        end
+      end
+
+     if blocked?(@coordinates)
+      self.random_1xSize(size)
+     end
+
+     @coordinates
+    end 
+
+    def linear_placer(coordinate, vert_hor)
+      new_coordinate = nil
+      if vert_hor == "v"
+        new_coordinate = coordinate[0].next + coordinate[1]
+      else
+        new_coordinate = coordinate[0] + coordinate[1].next
+      end
+      new_coordinate
+    end
+
+    def in_corner?(coordinate, ship_size)
+      the_corner = []
+      the_corner << (@sample_array[ - (ship_size-1)] + (@board_size - (ship_size - 2)).to_s)
+      
+      0.upto(ship_size - 3) do |x|      
+       the_corner << linear_placer(the_corner[x], "v")
+      end
+
+      #it makes 1 more coordinate than necessary
+      array_length = the_corner.length
+      if array_length == 2
+       0.upto(1) do |x|      
+       the_corner << linear_placer(the_corner[x], "h")
+      end
+      else
+       0.upto(array_length * (array_length - 1)) do |x|      
+        the_corner << linear_placer(the_corner[x], "h")
+       end
+      end
+      return the_corner.include?(coordinate)
+    end
+
+    def on_bottom_edge?(coordinate, ship_size)
+      @sample_array[-(ship_size - 1)..-1].include?(coordinate[0])
+    end
+
+    def on_right_edge?(coordinate, ship_size)
+      ((@board_size - ship_size + 2)..@board_size).to_a.include?(coordinate[1].to_i)
+    end
+    
+    def straight?(array)
+      array.sort!
+  	  straight_count = 0
+      1.upto(array.length-1) do |x|
+        if array[x-1][0].next + array[x-1][1] == array[x]
+          straight_count += 1
+        elsif array[x-1][0] + array[x-1][1].next == array[x]
+          straight_count += 1
+        end
+      end
+      true if straight_count == array.length - 1
+  	end
+
+    def blocked?(array)
+      blocked = false
+      array.each do |coordinate|
+        if @other_ship_array.include?(coordinate)
+          blocked = true
+          break
+        end
+      end
+      blocked
+    end
+  end
+end

data/test/battleship_test.rb

@@ -0,0 +1,53 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require './bin/battleship'
+require './lib/ship'
+require './lib/evaluator'
+require './lib/printer'
+require './lib/map'
+module EatTheOcean
+	class BattleshipTest < MiniTest::Test
+		def setup
+			@battleship = EatTheOcean::Battleship.new
+		end
+
+		def test_it_exists
+			assert @battleship
+		end
+
+		# def test_it_marks_initial_user_position_on_map
+		# 	@battleship.mark_initial_ship_position_on_map
+		# 	puts @battleship.user_map.grid_array
+		# 	puts @battleship.opponent_map.grid_array
+		# end
+
+		def test_it_validates_user_inputs
+			assert_equal "C2", @battleship.validate_input("C2")
+			# assert_equal Printer.invalid_input, @battleship.validate_input("CC")
+		end
+
+		# def test_it_registers_and_shows_successful_guesses
+		# 	@battleship.mark_initial_ship_position_on_map
+		# 	@battleship.opponent_ship_1x2.coordinates = ["A1", "A2"]
+		# 	@battleship.opponent_ship_1x3.coordinates = ["B1", "B2", "B3"]
+		#  	@battleship.guess("A1",@battleship.user_evaluator)
+		#  	@battleship.guess("B4",@battleship.user_evaluator)
+		# end
+
+		# def test_it_loops_for_repeat_guesses	
+		#  	@battleship.user_evaluator.guess_record = ["A1","A2"]
+		#  	@battleship.user_guess
+		# end
+
+		def test_it_outputs_the_user_sunk_status
+			@battleship.mark_initial_ship_position_on_map
+			@battleship.opponent_ship_1x2.coordinates = ["A1", "A2"]
+			@battleship.opponent_ship_1x3.coordinates = ["B1", "B2", "B3"]
+		 	@battleship.guess("A1",@battleship.user_evaluator)
+		 	@battleship.guess("A2",@battleship.user_evaluator)
+		 	@battleship.guess("B1",@battleship.user_evaluator)
+		 	@battleship.guess("B2",@battleship.user_evaluator)
+			@battleship.guess("B3",@battleship.user_evaluator)
+		end
+	end
+end

data/test/evaluator_test.rb

@@ -0,0 +1,112 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require './lib/ship'
+require './lib/evaluator'
+require './lib/printer'
+require './lib/map'
+module EatTheOcean
+	class EvaluatorTest < MiniTest::Test
+		def setup
+			@ship_1x2 = EatTheOcean::Ship.new(nil, 4)
+			@ship_1x2.coordinates = ["A1", "A2"]
+			@ship_1x3 = EatTheOcean::Ship.new(@ship_1x2.coordinates, 4)
+			@evaluator = EatTheOcean::Evaluator.new(@ship_1x2)
+			@map = EatTheOcean::Map.new(4)
+			@evaluator.map = @map
+		end
+
+		def test_it_exists
+			assert @evaluator
+		end
+
+		def test_it_registers_a_hit
+			@evaluator.hit("A1")
+			assert_equal 1, @ship_1x2.hits
+			@evaluator.hit("A3")
+			assert_equal 1, @ship_1x2.hits
+		end
+
+		def test_it_returns_true_on_hit
+			assert @evaluator.hit("A1")
+			refute @evaluator.hit("A4")
+		end
+
+		def test_it_hits_on_a_hit
+			@evaluator.hit("A1")
+			@evaluator.hit("A2")
+			assert_equal 2, @ship_1x2.hits
+		end
+
+		def test_it_sinks_a_1x2
+			@evaluator.hit("A1")
+			@evaluator.hit("A2")
+			assert_equal 1, @ship_1x2.sunk
+		end
+
+		def test_it_sinks_a_1x3
+			@ship_1x3.random_1xSize(3)
+			@evaluator.ship_array[1] = @ship_1x3
+			@ship_1x3.coordinates[0] = "B1"
+			@ship_1x3.coordinates[1] = "B2"
+			@ship_1x3.coordinates[2] = "B3"
+			@evaluator.hit("B1")
+			@evaluator.hit("B2")
+			@evaluator.hit("B3")
+			assert_equal 1, @ship_1x3.sunk
+		end
+
+		def test_it_ouputs_the_hit_entries
+			@evaluator.hit("A1")
+			@evaluator.hit("A2")
+			assert_equal ["A1", "A2"], @evaluator.hits_record
+		end
+
+		def test_it_ouputs_the_miss_entries
+			miss_evaluator = EatTheOcean::Evaluator.new(Ship.new)
+			map = Map.new(4)
+			miss_evaluator.map = map
+			miss_evaluator.hit("A3")
+			miss_evaluator.hit("A4")
+			assert_equal ["A3", "A4"], miss_evaluator.misses_record
+		end
+
+		def test_it_shows_hit_coordinates
+			@ship_1x3.random_1xSize(3)
+			@evaluator.ship_array[1] = @ship_1x3
+			@ship_1x3.coordinates = ["B1", "B2", "B3"]
+			@ship_1x2.coordinates.each do |coordinate|
+				@map.grid_mark(coordinate, "🐬")
+			end
+			@ship_1x3.coordinates.each do |coordinate|
+				@map.grid_mark(coordinate, "🐋")
+			end
+			@evaluator.hit("A1")
+			@evaluator.hit("B2")
+			@evaluator.hit("B3")
+			@evaluator.hit("B4")
+			@evaluator.hit("D1")
+			@evaluator.hit("D2")
+			puts @map.grid_array
+
+		end 
+
+		def test_it_sinks_both_ships
+			@ship_1x2.random_1x2
+			@ship_1x3.random_1xSize(3)
+			@evaluator.ship_array[0] = @ship_1x2
+			@evaluator.ship_array[1] = @ship_1x3
+			@ship_1x2.coordinates[0] = "A1"
+			@ship_1x2.coordinates[1] = "A2"
+			@ship_1x3.coordinates[0] = "B1"
+			@ship_1x3.coordinates[1] = "B2"
+			@ship_1x3.coordinates[2] = "B3"
+			@evaluator.hit("A1")
+			@evaluator.hit("A2")
+			@evaluator.hit("B1")
+			@evaluator.hit("B2")
+			@evaluator.hit("B3")
+			assert_equal 1, @ship_1x3.sunk
+			assert_equal 1, @ship_1x2.sunk
+		end
+	end
+end

data/test/map_test.rb

@@ -0,0 +1,46 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require './lib/ship'
+require './lib/evaluator'
+require './lib/printer'
+require './lib/map'
+module EatTheOcean
+	class MapTest < MiniTest::Test
+		def setup
+			@map = EatTheOcean::Map.new(12)
+		end
+
+		# def test_it_exists
+		# 	assert @map
+		# end
+
+		def test_it_generates_borders_of_varying_size
+			@map.size = 16
+			puts @map.border_create
+		end
+
+		# def test_it_generates_number_line
+		# 	puts @map.grid_create
+		# end
+
+		# def test_it_generates_the_grid
+		# 	@map.grid_create
+		# 	@map.border_create
+		# 	puts @map.grid_array
+		# end
+
+		def test_it_places_marks
+			@map.grid_create
+			@map.border_create
+			@map.grid_mark("A1", "🐋")
+			@map.grid_mark("A2", "🐋")
+			@map.grid_mark("A3", "🍣")
+			@map.grid_mark("B1", "🐬")
+			@map.grid_mark("B2", "🐬")
+			@map.grid_mark("D1", "🐬")
+			@map.grid_mark("D2", "🍣")
+			@map.grid_mark("D3", "💦")
+			puts @map.grid_array
+		end
+	end
+end

data/test/ship_test.rb

@@ -0,0 +1,86 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require './lib/ship'
+require './lib/evaluator'
+require './lib/printer'
+require './lib/map'
+module EatTheOcean
+  class ShipTest < MiniTest::Test
+  	def setup
+  		@ship_1x2 = EatTheOcean::Ship.new
+      @ship_1x2.coordinates = ["A1", "A2"]
+  		@ship_1x3 = EatTheOcean::Ship.new(@ship_1x2.coordinates)
+      @ship_1x3.random_1xSize(3)
+  	end
+
+  	def test_it_generates_a_predictable_1x2_ship
+  		assert_equal ["A1", "A2"], @ship_1x2.coordinates
+  	end
+
+  	def test_it_generates_a_random_1x2_ship
+  		random_1x2 = EatTheOcean::Ship.new(nil, 10)
+  		puts random_1x2.random_1x2
+  	end
+
+    def test_it_straights
+      assert @ship_1x2.straight?(["A1","A2"]) 
+      assert @ship_1x2.straight?(["A1","B1"]) 
+      refute @ship_1x2.straight?(["A1","B2"])
+    end
+
+    # def test_it_blocks
+    #   refute @ship_1x3.blocked?(["B2","B3","B4"])
+    #   assert @ship_1x3.blocked?(["A1","A2","A3"])
+    #   assert @ship_1x3.blocked?(["A2","B2","C2"])
+    # end
+
+    def test_it_places_linearly_or_vertically
+       assert_equal "B2", @ship_1x3.linear_placer("A2","v")
+       assert_equal "A3", @ship_1x3.linear_placer("A2","h")
+    end
+
+    def test_is_the_given_ship_cornered
+      assert @ship_1x3.in_corner?("C3", 3)
+      refute @ship_1x3.in_corner?("C2", 3)
+      assert @ship_1x3.in_corner?("C4", 3)
+      assert @ship_1x3.in_corner?("D4", 3)
+      another_ship = EatTheOcean::Ship.new(nil, 5)
+      assert another_ship.in_corner?("E3", 4)
+      assert another_ship.in_corner?("C3", 4)
+      refute another_ship.in_corner?("C2", 4)
+      assert another_ship.in_corner?("D4", 4)
+      assert another_ship.in_corner?("E5", 4)
+    end
+
+    def test_it_knows_bottom_and_top_edges
+      new_ship = EatTheOcean::Ship.new(nil, 4)
+      assert new_ship.on_bottom_edge?("C2", 3)
+      refute new_ship.on_bottom_edge?("B2", 3)
+      assert new_ship.on_right_edge?("C3",3)
+      refute new_ship.on_right_edge?("C2",3)
+      new_ship_2 = EatTheOcean::Ship.new(nil, 6)
+      assert new_ship_2.on_bottom_edge?("C2", 5)
+      refute new_ship_2.on_bottom_edge?("B2", 5)
+      assert new_ship_2.on_right_edge?("C3", 5)
+      refute new_ship_2.on_right_edge?("C2", 5)
+    end
+
+    def test_it_generates_random_coordinate_according_to_size
+      @ship_1x2.coordinates = ["A1", "A2"]
+      new_ship = EatTheOcean::Ship.new(@ship_1x2.coordinates, 4)
+      puts new_ship.random_1xSize(3)
+    end
+
+    # def test_it_generates_a_1x4_on_a_5x5_grid
+    #   ship_1x2 = Ship.new(nil, 9)
+    #   ship_1x2.random_1x2
+    #   ship_1x3 = Ship.new(ship_1x2.coordinates, 9)
+    #   ship_1x3.random_1xSize(3)
+    #   ship_1x4 = Ship.new(ship_1x2.coordinates + ship_1x3.coordinates, 9)
+    #   ship_1x4.random_1xSize(4)
+
+    #   puts ship_1x2.coordinates + ship_1x3.coordinates + ship_1x4.coordinates
+    # end
+
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: eat_the_ocean
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jeffrey Gu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A marine animal-skinned version of battleship. You can initialize 4x4,
+  6x6, and 8x8 gameboards.
+email: jeffwgu@gmail.com
+executables:
+- eat_the_ocean
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/battleship.rb
+- bin/eat_the_ocean
+- lib/battleship_hardmedium.rb
+- lib/evaluator.rb
+- lib/map.rb
+- lib/printer.rb
+- lib/ship.rb
+- test/battleship_test.rb
+- test/evaluator_test.rb
+- test/map_test.rb
+- test/ship_test.rb
+- LICENSE
+- README
+homepage: http://www.jeffreygu.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A marine animal-skinned version of battleship.
+test_files:
+- test/battleship_test.rb
+- test/evaluator_test.rb
+- test/map_test.rb
+- test/ship_test.rb