rb_battleship 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 931cc1b1f8aa09c59792fea9b6b1b0f2a5ac44a5
+  data.tar.gz: ef85817e4cfe22c5e8b5c4d6e815c2b94f0c0b4e
+SHA512:
+  metadata.gz: bb0a90101f5609c42a4a8395e5525931ac8aaa0c3aa7782541cd8dc3b8b53fdb0b536742dcfb0b6dbf022fcf7d057f594932f354273925201ba8031793666315
+  data.tar.gz: d23cad03fc419bddd789214d16cae28c2beb925c73696ef19a328796201c23692065449c0a2c50b9a5627db9272588e28c8d71d24d6cacc5e357aa3c8d528451

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+.ruby-version
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+gemspec

data/README.md

@@ -0,0 +1,62 @@
+# :ship: :boom: Battleship :boom: :ship:
+The objective of this task is to build a battleship game for two players in Ruby in a terminal.
+
+## Design
+
+### SRP
+The code design follows the single responsibility principle by using a dedicated class for any specific task.  
+
+## Installation
+Install the gem from your shell:
+```shell
+gem install battleship
+```
+
+## Gameplay
+The gem includes a single binary you can use to start a new game:
+```shell
+battleship
+******* 1° round
+******* Player 1 turn
+place small (3x1) ship on grid by specifying coordinates and cardinal point separated by spaces (ie 1 3 SE):
+>
+```
+
+## Tests
+The gem is covered, where possible, by fast, isolated unit testing:gem is covered, where possible, by fast, isolated unit testing. Execute them all by:
+```shell
+bundle exec rake
+```
+
+## Kata objectives
+* :warning: You should not require any gems aside from ones to help you write any tests (rspec, minitest...). :warning:
+* Your code must be tested as much as possible.
+* Each step must be 100% done before moving to the next. We won't take into account any part done in advance.
+* You should explain how to run your game (and the tests) in a README.md file in the root of your project.
+
+## 1st step - Board setup
+The game is played on 5x5 grids (one per player). Your first task is to set the game up:
+* Players have 2 ships each to place on their grid. A small ship (3x1 side) and large one (4x1 size)
+* Players are asked in turn to place their ships on their board (ie: interactively)
+* A ship can't be placed out of bounds nor on the same space as another ship.
+
+## 2nd step - Gameplay setup
+Once all the ships are placed the game begins! Now you have to set the gameplay mechanisms up:
+* Players take turns to shoot at the opponent grid one after the other by selecting coordinates.
+* Each shot receives a Hit, Miss or Sink response.
+* The winner is the player who sinks all of their opponent ships first
+
+## 3rd step - Gameplay improvements
+At this point the game works and we'd like some improvements of some of its mechanisms:
+* Starting player is determined at random.
+* If a shot attempt is made out of bounds the game offers a retry.
+* When the game is finished it gives the option to play again.
+
+## 4th step - Bonus
+This part is here to spice things up! :boom: We'd like to have these features added to the game:
+* Ships can now be placed diagonally.
+* If a player misses a shot 3 times in a row the game gives a hint of a valid shot.
+* The game now works in a "Best of 3" match mode:
+> If player 1 wins the first game, the match is not over yet because player 2 can still win the 2 other games and win the match.
+> If player 1 wins first 2 consecutive games, then the other player can possibly win 1 game maximum, which is not sufficient to beat the 2 games won by player 1.
+> If each player won 1 of the first 2 games then the third game is played. Whoever wins the third game is declared winner of the match.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList["spec/**/*_spec.rb"]
+end
+
+task :default => :spec

data/battleship.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "battleship/version"
+
+Gem::Specification.new do |s|
+  s.name = "rb_battleship"
+  s.version = Battleship::VERSION
+  s.authors = ["costajob"]
+  s.email = ["costajob@gmail.com"]
+  s.license = "MIT"
+  s.summary = "Implementation of the Battleship code kata"
+  s.homepage = "https://github.com/costajob/battleship.git"
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir = "bin"
+  s.executables << "battleship" 
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 2.3.1"
+  s.add_development_dependency "bundler", "~> 1.16"
+  s.add_development_dependency "rake", "~> 12.3"
+  s.add_development_dependency "minitest", "~> 5.1"
+end

data/bin/battleship

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "battleship"
+
+Battleship::GamePlay.call

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "battleship"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/battleship.rb

@@ -0,0 +1,7 @@
+require "battleship/gameplay"
+
+module Battleship
+  extend self
+
+  CARDINALS = %w[N E S W NE NW SE SW]
+end

data/lib/battleship/coord.rb

@@ -0,0 +1,38 @@
+module Battleship
+  class Coord
+    class FactoryError < StandardError; end
+
+    attr_reader :x, :y
+
+    def self.orig
+      @orig ||= new(0, 0)
+    end
+
+    def self.factory(data)
+      new(*data.split(" "))
+    rescue ArgumentError
+      fail FactoryError.new("coordinate must be specified as 'x y' (ie 1 2)")
+    end
+
+    def initialize(x, y)
+      @x = x.to_i.abs
+      @y = y.to_i.abs
+    end
+
+    def to_s
+      "#{x} #{y}"
+    end
+
+    def >=(other)
+      x >= other.x && y >= other.y
+    end
+
+    def <=(other)
+      x <= other.x && y <= other.y
+    end
+
+    def ==(other)
+      x == other.x && y == other.y
+    end
+  end
+end

data/lib/battleship/gameplay.rb

@@ -0,0 +1,81 @@
+require "battleship/player"
+
+module Battleship
+  class GamePlay
+    STARS = "*" * 7
+    START_MSG = -> (nbr) { "#{STARS} #{nbr}° round" }
+    TURN_MSG = -> (name) { "#{STARS} #{name} turn" }
+    ROUND_MSG = -> (name) { "#{STARS} #{name} wins the round" }
+    GAMEOVER_MSG = -> (name) { "#{STARS} #{name} wins the game" }
+    ANSWERS = %w[Y N y n]
+    MATCHES = 3
+
+    def self.call
+      new.call
+    end
+
+    attr_reader :matches, :output
+
+    def initialize(player_class=Player, output=STDOUT)
+      @player_class = player_class
+      @players = nil
+      @winner = nil
+      @matches = []
+      @output = output
+    end
+
+    def players
+      return @players if @players
+      p1, p2 = [1, 2].map { |i| @player_class.factory(name: "Player #{i}", output: @output) }
+      p1.enemy = p2
+      p2.enemy = p1
+      @players = [p1, p2]
+    end
+
+    def call
+      output.puts(GAMEOVER_MSG.call(play))
+    end
+
+    private def play
+      loop do
+        output.puts(START_MSG.call(matches.size+1))  
+        setup
+        round
+        return winner.name if winner
+      end
+    end
+
+    private def winner
+      @winner ||= players.detect do |player|
+        matches.count(player.name) > 1
+      end
+    end
+
+    private def setup
+      players.shuffle.each do |player|
+        output.puts(TURN_MSG.call(player.name))
+        player.setup
+      end
+    end
+
+    private def fight
+      loop do
+        players.each do |player|
+          output.puts(TURN_MSG.call(player.name)) 
+          player.shot
+          return player.name if player.enemy.gameover?
+        end
+      end
+    end
+
+    private def round
+      matches << fight
+      output.puts(ROUND_MSG.call(matches[-1]))
+      reset!
+    end
+
+    private def reset!
+      @players = nil
+    end
+  end
+end

data/lib/battleship/grid.rb

@@ -0,0 +1,82 @@
+require "forwardable"
+require "battleship/coord"
+
+module Battleship
+  class Grid
+    extend Forwardable
+
+    SIZE = 4
+    PLACE_ERR = "ship placed ouside of grid and/or overlapping an exisitng one"
+    COORD_ERR = -> (grid) { "coordinate is ouside of grid (#{grid.bot_left}) - (#{grid.top_right})" }
+    HIT = "Hit"
+    MISS = "Miss"
+    SINK = "Sink"
+
+    class PlacingError < StandardError; end
+    
+    def self.factory(coord_class=Coord)
+      new(coord_class.orig, coord_class.new(SIZE, SIZE))
+    end
+
+    def_delegators :@ships, :include?, :empty?, :size
+
+    attr_reader :bot_left, :top_right, :ships
+
+    def initialize(bot_left, top_right)
+      @bot_left = bot_left
+      @top_right = top_right 
+      @ships = []
+    end
+
+    def to_s
+      "bot_left=#{bot_left} top_right=#{top_right} ships=#{ships.size}"
+    end
+
+    def <<(ship)
+      fail PlacingError.new(PLACE_ERR) unless valid?(ship)
+      ships << ship
+    end
+
+    def shot(coord)
+      fail PlacingError.new(COORD_ERR.call(self)) unless included?(coord)
+      data = damages(coord)
+      purge!
+      return SINK if data.any? { |d| d < 0 }
+      return HIT if data.any? { |d| d > 0 }
+      MISS
+    end
+
+    def footprint
+      ships.map(&:footprint).flatten
+    end
+
+    private def damages(coord)
+      ships.reduce([]) do |acc, ship|
+        damage = ship.strike(coord)
+        acc << damage
+      end
+    end
+
+    private def purge!
+      ships.reject!(&:empty?)
+    end
+
+    private def valid?(ship)
+      within?(ship) && !overlap?(ship)
+    end
+
+    private def within?(ship)
+      ship.footprint.all? { |coord| included?(coord) }
+    end
+
+    private def included?(coord)
+      coord >= bot_left && coord <= top_right
+    end
+
+    private def overlap?(ship)
+      footprint.any? do |coord|
+        ship.footprint.any? { |c| c == coord }
+      end
+    end
+  end
+end

data/lib/battleship/player.rb

@@ -0,0 +1,80 @@
+require "forwardable"
+require "battleship/grid"
+require "battleship/position"
+require "battleship/ship"
+
+module Battleship
+  class Player
+    extend Forwardable
+
+    PLACE_MSG = -> (ship) { "place #{ship.name} ship on grid by specifying coordinates and cardinal point separated by spaces (ie 1 3 SE):" }
+    SHOT_MSG = "enter coordinates for shooting your enemy grid (ie 2 3):"
+    TIP_MSG = -> (shot, coord) { "#{shot}, you should try with the (#{coord}) coordinates next time" }
+    TIP_THRESHOLD = 3
+
+    class MissesError < StandardError; end
+
+    def_delegator :@grid, :empty?, :gameover?
+
+    def self.factory(name:, grid_class: Grid, output: STDOUT)
+      new(name: name, grid: grid_class.factory, output: output) 
+    end
+
+    attr_reader :name, :grid, :ships
+    attr_accessor :enemy
+
+    def initialize(name:, grid:, output: STDOUT)
+      @name = name
+      @grid = grid
+      @misses = 0
+      @output = output
+      @pos = nil
+      @coord = nil
+    end
+
+    def setup(ships=[Ship.small, Ship.large])
+      Array(ships).each { |ship| place(ship) }
+    end
+
+    def shot(coord_class=Coord)
+      @output.puts(SHOT_MSG)
+      @coord ||= STDIN.gets
+      shot = enemy.grid.shot(coord_class.factory(@coord.chomp))
+      @output.puts(report(shot))
+      @coord = nil
+    rescue grid.class::PlacingError, coord_class::FactoryError => e
+      @output.puts(e.message)
+      @coord = nil
+      retry
+    end
+
+    private def report(shot)
+      return shot unless tip?(shot) 
+      coord = enemy.grid.footprint.sample
+      TIP_MSG.call(shot, coord)
+    end
+
+    private def tip?(shot)
+      return reset! unless shot == grid.class::MISS
+      @misses += 1
+      @misses >= TIP_THRESHOLD
+    end
+
+    private def reset!
+      @misses = 0
+      false
+    end
+
+    private def place(ship, pos_class=Position)
+      @output.puts(PLACE_MSG.call(ship))
+      @pos ||= STDIN.gets
+      ship.place(pos_class.factory(@pos.chomp))
+      grid << ship
+      @pos = nil
+    rescue grid.class::PlacingError, pos_class::FactoryError  => e
+      @output.puts(e.message)
+      @pos = nil
+      retry
+    end
+  end
+end

data/lib/battleship/position.rb

@@ -0,0 +1,31 @@
+require "battleship/coord"
+
+module Battleship
+  class Position
+    class CardinalError < StandardError; end
+    class FactoryError < StandardError; end
+
+    def self.factory(data)
+      new(*data.split(" "))
+    rescue ArgumentError
+      fail FactoryError.new("position must be specified as 'x y cardinal' (ie 1 2 N)")
+    end
+
+    attr_reader :coord
+    attr_accessor :cardinal
+
+    def initialize(x, y, cardinal, coord_class=Coord)
+      @coord = coord_class.new(x, y)
+      @cardinal = check(cardinal)
+    end
+
+    def to_s
+      "#{coord} #{cardinal}"
+    end
+
+    private def check(cardinal)
+      return cardinal if CARDINALS.include?(cardinal)
+      fail CardinalError.new("#{cardinal} is not a valid cardinal point")
+    end
+  end
+end

data/lib/battleship/ship.rb

@@ -0,0 +1,63 @@
+require "forwardable"
+
+module Battleship
+  class Ship
+    extend Forwardable
+
+    SMALL_LEN = 3
+    LARGE_LEN = 4
+    WIDTH = 1
+
+    def_delegators :@footprint, :empty?
+
+    def self.small
+      new(SMALL_LEN, WIDTH, "small (#{SMALL_LEN}x#{WIDTH})")
+    end
+
+    def self.large
+      new(LARGE_LEN, WIDTH, "large (#{LARGE_LEN}x#{WIDTH})")
+    end
+
+    attr_accessor :name, :len, :wid, :footprint
+
+    def initialize(len, wid, name=nil)
+      @len = len.to_i
+      @wid = wid.to_i
+      @name = name.to_s
+      @footprint = []
+    end
+
+    def to_s
+      "len=#{len} wid=#{wid} footprint=(#{footprint.map(&:to_s).join(', ')})"
+    end
+
+    def place(position)
+      coord = position.coord
+      @footprint = case position.cardinal
+      when 'N'
+        len.times.map { |i| coord.class.new(coord.x, coord.y + i) }
+      when 'E'
+        len.times.map { |i| coord.class.new(coord.x + i, coord.y) }
+      when 'S'
+        len.times.map { |i| coord.class.new(coord.x, coord.y - i) }
+      when 'W'
+        len.times.map { |i| coord.class.new(coord.x - i, coord.y) }
+      when 'NE'
+        len.times.map { |i| coord.class.new(coord.x + i, coord.y + i) }
+      when 'NW'
+        len.times.map { |i| coord.class.new(coord.x - i, coord.y + i) }
+      when 'SE'
+        len.times.map { |i| coord.class.new(coord.x + i, coord.y - i) }
+      when 'SW'
+        len.times.map { |i| coord.class.new(coord.x - i, coord.y - i) }
+      end
+    end
+
+    def strike(coord)
+      hit = @footprint.delete(coord)
+      return -1 if empty?
+      return 1 if hit
+      0
+    end
+  end
+end

data/lib/battleship/version.rb

@@ -0,0 +1,3 @@
+module Battleship
+  VERSION = "1.0.1"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: rb_battleship
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- costajob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+description: 
+email:
+- costajob@gmail.com
+executables:
+- battleship
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- battleship.gemspec
+- bin/battleship
+- bin/console
+- bin/setup
+- lib/battleship.rb
+- lib/battleship/coord.rb
+- lib/battleship/gameplay.rb
+- lib/battleship/grid.rb
+- lib/battleship/player.rb
+- lib/battleship/position.rb
+- lib/battleship/ship.rb
+- lib/battleship/version.rb
+homepage: https://github.com/costajob/battleship.git
+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.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Implementation of the Battleship code kata
+test_files: []