alex_butirskiy_sea_battle 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: adb9cdd2b8492bed6cdb7e86b34fe3af60f42267
+  data.tar.gz: 59c47a4619e0ca90d2014d3fc0ffd66d32e3c330
+SHA512:
+  metadata.gz: 239e51424133bf7838a5920de34b49897b3b844e52fe37fb59b4f7f0a562ecc178ae80bfda0c3f2d2fb896275cc75040114f85d8599767f32cda9c179cf62634
+  data.tar.gz: 79b6477356c70df0ceda1e05c87b7b8883b9c4ca6fc1c8c2f65c9dc91b711d18e084c7246030db477a84a6295807b3e6fed3971454d86d3041c46ae0beb3b4ea

data/lib/alex_butirskiy_sea_battle.rb

@@ -0,0 +1,3 @@
+require_relative './game.rb'
+
+Game.new.run

data/lib/board.rb

@@ -0,0 +1,189 @@
+require_relative  'cell'
+require_relative  'ship'
+
+class BoardSizeError < RuntimeError; end
+class OutOfBoardError < RuntimeError; end
+class ShipSizeError < RuntimeError; end
+class NotRoomError < RuntimeError; end
+
+# class Board describes game board
+class Board
+  include Direction
+  include State
+
+  def initialize(size_x = 10, size_y = 10, name = '')
+    unless (1..20).include?(size_x) && (1..20).include?(size_y)
+      fail BoardSizeError, 'size should be in (1..20) range'
+    end
+
+    @size_x, @size_y, @player_name = size_x, size_y, name
+
+    @cells, @ships = [], []
+
+    @alphabet = ('A'..'Z').map { |a| a }
+
+    0.upto(size_x - 1) do |x|
+      @cells[x] = []
+      0.upto(size_y - 1) { |y| @cells[x][y] = Cell.new(x, y) }
+    end
+  end
+
+  def cell(col, row)
+    @cells[col][row]
+  end
+
+  def put_ship(head_x, head_y, size, dir)
+    head_x, head_y  = x_y_normalize head_x, head_y
+
+    unless (1..5).include? size
+      fail ShipSizeError, 'Ship size should be in range (1..5)'
+    end
+
+    # it makes list of cells which will be occupied by ship
+    # and checks for board border crossing
+    cell_list = []
+    x = head_x
+    y = head_y
+    size.times do |i|
+      case dir
+      when NORTH
+        fail NotRoomError if y == 0 && i != size - 1
+        cell_list[i] = [x, y]
+        y -= 1
+      when EAST
+        fail NotRoomError if x == 0 && i != size - 1
+        cell_list[i] = [x, y]
+        x -= 1
+      when SOUTH
+        fail NotRoomError if y == @size_y - 1 && i != size - 1
+        cell_list[i] = [x, y]
+        y += 1
+      when WEST
+        fail NotRoomError if x == @size_x - 1 && i != size - 1
+        cell_list[i] = [x, y]
+        x += 1
+      end
+    end
+
+    # it checks if the nearest cells have already been occupied
+    # algorithm isn't optimal because some cells are being checked many times
+    cell_list.each do |x, y|
+      fail NotRoomError, 'Other ship is here' if cell(x, y).state != EMPTY
+      if x != 0
+        if  (cell(x - 1, y).state != EMPTY) ||
+            (y != 0 && cell(x - 1,  y - 1).state != EMPTY) ||
+            (y != @size_y - 1 && cell(x - 1, y + 1).state != EMPTY)
+          fail NotRoomError, "Other ship is near [#{x}:#{y}]"
+        end
+      end
+      if  (y != 0 && cell(x, y - 1).state != EMPTY) ||
+          (y != @size_y - 1 && cell(x, y + 1).state != EMPTY)
+        fail NotRoomError, "Other ship is near [#{x}:#{y}]"
+      end
+      if x != @size_x - 1
+        if  (cell(x + 1, y).state != EMPTY) ||
+            (y != 0 && cell(x + 1, y - 1).state != EMPTY) ||
+            (y != @size_y - 1 && cell(x + 1, y + 1).state != EMPTY)
+          fail NotRoomError, 'Other ship is near [#{x}:#{y}]'
+        end
+      end
+    end
+
+    @ships << Ship.new(cell_list.map { |x, y|  cell x, y })
+  end
+
+  def shoot(x, y)
+    # there is a posibility of using letters as X coordinate
+    x, y = x_y_normalize x, y
+    c = cell(x, y)
+    case c.state
+    when EMPTY
+      c.state = MISSED
+      return 'MISSED'
+    when SHIP
+      ship = @ships.find { |sh| sh.include? c }
+      fail FatalError, 'Mismatch between cell and ship tables' if ship.nil?
+      c. state = BROKEN
+      ship.alive? ? (return 'INJURED') : (return 'KILLED')
+    when MISSED, BROKEN
+      return 'ALREADY SHOT'
+    end
+  end
+
+  def is_ship_alive?
+    @ships.each { |sh| return true if sh.alive? }
+    false
+  end
+
+  def display(str)
+    fail TypeError, 'str should be Fixnum' unless str.class == Fixnum
+    offset = 2
+    res = ''
+    case str
+    when 0
+      res << @player_name.center(@size_x + 4)
+      res << ' '
+    when 1, 1 + @size_y + 1
+      res << ' ' * 2
+      (@size_x).times { |i| res << @alphabet[i] }
+      res << ' ' * 3
+    when (offset..@size_y - 1 + offset)
+      res << (@size_y - 1 - (str - offset)).to_s
+      res << '|'
+      @size_x.times do |x|
+        case @cells[x][@size_y - 1 - (str - offset)].state
+        when SHIP then res << 'O'
+        when BROKEN then res << 'X'
+        when MISSED then res << '*'
+        else res << ' '
+        end
+      end
+      res << '|'
+      res << (@size_y - 1 - (str - offset)).to_s
+      res << ' '
+    end
+    res
+  end
+
+  def generate(*list)
+    5.downto(1).each do |size|
+      count = list[size - 1]
+      count.times do
+        100.times do |try|
+          begin
+            head_x = rand(@size_x)
+            head_y = rand(@size_y)
+            dir = rand(4)
+            put_ship head_x, head_y, size, dir
+            break
+          rescue NotRoomError
+            raise NotRoomError, 'Too much ships' if try == 100 - 1
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  # it converts x to number if it is a letter
+  # then validates them
+  # returns x, y
+  def x_y_normalize(x, y)
+    x = @alphabet.index(x.upcase) if x.is_a?(String)
+    p = x_y_normalize_params
+    fail OutOfBoardError, "x should be in range #{p[:x_n]} or #{p[:x_l]}"\
+      unless (0..@size_x - 1).include? x
+    fail OutOfBoardError, "y should be in range #{p[:y]}"\
+      unless (0..@size_y - 1).include? y
+    [x, y]
+  end
+
+  def x_y_normalize_params
+    {
+      x_n:  "(0..#{@size_x - 1})",
+      x_l:  "(\"A\"..\"#{@alphabet[@size_x - 1]}\"))",
+      y:    "(0..#{@size_x - 1})"
+    }
+  end
+end

data/lib/cell.rb

@@ -0,0 +1,30 @@
+# Describes cell states
+module State
+  EMPTY   = 0   # Nothing except sea water
+  SHIP    = 1   # Occupied by ship
+  BROKEN  = 2   # Occupied by broken ship
+  MISSED  = 3   # There was a mishit here
+end
+
+# class Cell describes cell state
+class Cell
+  include State
+  attr_accessor :state
+  def initialize(col, row, st = EMPTY)
+    @state = st
+    @col = col
+    @row = row
+  end
+
+  def state=(new_st)
+    if (State.constants.collect { |sym| State.const_get sym }).include? new_st
+      @state = new_st
+    else
+      fail TypeError
+    end
+  end
+
+  def to_s
+    "Cell [#{@col}:#{@row}] State = #{@state}"
+  end
+end

data/lib/game.rb

@@ -0,0 +1,134 @@
+require_relative  'board.rb'
+
+## Default setting constants
+module Defaults
+  SIZE_X = 20
+  SIZE_Y = 10
+  PLAYER_1_NAME   = 'Player 1'
+  PLAYER_2_NAME   = 'Player 2'
+  PLAYER_NAME     = 'Human'
+  COMPUTER_NAME   = 'Computer'
+  COMPUTER_1_NAME = 'Computer 1'
+  COMPUTER_2_NAME = 'Computer 2'
+
+  SHIP_1_COUNT = 5
+  SHIP_2_COUNT = 4
+  SHIP_3_COUNT = 3
+  SHIP_4_COUNT = 2
+  SHIP_5_COUNT = 1
+
+  SHIPS_COUNT = [SHIP_1_COUNT, SHIP_2_COUNT, SHIP_3_COUNT,
+                 SHIP_4_COUNT, SHIP_5_COUNT]
+end
+
+# Main game class
+# Use Game.new.run
+class Game
+  include Defaults
+  def initialize
+    @alphabet = ''
+    ('A'..'Z').each { |a| @alphabet << a }
+  end
+
+  def display(b1, b2)
+    system('clear')
+    (SIZE_Y + 5).times do |i|
+      puts b1.display(i) << ' ' * 3 << b2.display(i)
+    end
+  end
+
+  def comp_vs_comp
+    board = [Board.new(SIZE_X, SIZE_Y, COMPUTER_1_NAME),
+             Board.new(SIZE_X, SIZE_Y, COMPUTER_2_NAME)]
+
+    board[0].generate(*SHIPS_COUNT)
+    board[1].generate(*SHIPS_COUNT)
+
+    player_name = [COMPUTER_1_NAME, COMPUTER_2_NAME]
+
+    current_player = 0
+    result = ' '
+    auto = :OFF
+    delay = 1
+    loop do
+      if auto == :OFF
+        display(*board)
+        puts "Turn: #{player_name[current_player]}\n"
+        puts "Press:Enter to continue\tQ+Enter - exit\tA+Enter - demo mode"
+        inp = gets.chop
+        case inp
+        when 'Q', 'q' then return
+        when 'A', 'a' then auto = :ON
+        when 'AF', 'af'
+          auto = :ON
+          delay = 0.2
+        end
+      end
+
+      hit = loop do
+        hit = [rand(SIZE_X), rand(SIZE_Y)]
+        result = board[current_player - 1].shoot(*hit)
+        break hit if result != 'ALREADY SHOT'
+      end
+
+      display(*board)
+      puts "Turn: #{player_name[current_player]}"
+      puts "Hit: #{@alphabet[hit[0]]}#{hit[1]} - #{result}"
+
+      case result
+      when 'MISSED'
+        current_player == 0 ? (current_player = 1) : (current_player = 0)
+      when 'INJURED'
+        sleep(delay)
+        next
+      when 'KILLED'
+        if board[current_player - 1].is_ship_alive? == false
+          congratulation player_name[current_player]
+          return
+        end
+        sleep(delay)
+      end
+      sleep(delay)
+    end
+  end
+
+  def congratulation(name)
+    puts "\nCONGRATULATION!!!"
+    puts "#{name} has won"
+    puts 'GAME OVER'
+    sleep(2)
+  end
+
+  def human_vs_human
+    puts "\nUnder construction. Try later..."
+  end
+
+  def human_vs_comp
+    puts "\nUnder construction. Try later..."
+  end
+
+  def run
+    system('clear')
+
+    greeting
+    input = gets.chop
+
+    case input
+    when '1' then comp_vs_comp
+    when '2' then human_vs_comp
+    when '3' then human_vs_human
+    when 'q', 'Q' then
+    end
+  end
+
+  private
+
+  def greeting
+    puts "\n\n\n************** NAVAL BATTLE****************"
+    puts 'Choose game mode:'
+    puts '1 - Computer vs Computer'
+    puts '2 - Human vs Computer'
+    puts '3 - Human vs Human'
+    puts
+  end
+end

data/lib/ship.rb

@@ -0,0 +1,27 @@
+require_relative  'cell'
+
+# Ship direction constants
+module Direction
+  NORTH = 0
+  EAST  = 1
+  SOUTH = 2
+  WEST  = 3
+end
+
+# class Ship describes ship state
+class Ship
+  include State
+  def initialize(cells)
+    @cells = cells
+    @cells.each { |c| c.state = SHIP }
+  end
+
+  def alive?
+    @cells.each { |c| return true if c.state == SHIP }
+    false
+  end
+
+  def include?(cell)
+    @cells.include? cell
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: alex_butirskiy_sea_battle
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Butirskiy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-12 00:00:00.000000000 Z
+dependencies: []
+description: "A simple computr game. \n There are three playing modes:\n\tHuman vs
+  Human\n\tHuman vs Computer\n\t Computer vs Computer"
+email: butirskiy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/alex_butirskiy_sea_battle.rb
+- lib/board.rb
+- lib/cell.rb
+- lib/game.rb
+- lib/ship.rb
+homepage: http://rubygems.org/gems/alex_butirskiy_sea_battle
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Sea battle game
+test_files: []