Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Added in players from Ipswich Ruby User Group

  • Loading branch information...
commit 150804451b54404ed35d48f71c5e41b1dc992d27 1 parent f6d3b2f
Tom Crinson authored
View
81 contestants/iprug/anders_player.rb
@@ -0,0 +1,81 @@
+class AndersPlayer
+ def initialize
+ @aim = Aim.new()
+ end
+
+ def name
+ "Anders Player"
+ end
+
+ def new_game
+ randy = rand(2)
+ if(randy == 1)
+ layout = [
+ [rand(5), rand(2), 5, :across],
+ [rand(6), rand(2) + 2, 4, :across],
+ [rand(7), rand(2) + 4, 3, :across],
+ [rand(7), rand(2) + 6, 3, :across],
+ [rand(8), rand(2) + 8, 2, :across]
+ ]
+ else
+ layout = [
+ [rand(2), rand(5), 5, :down],
+ [rand(2)+2, rand(6), 4, :down],
+ [rand(2)+4, rand(7), 3, :down],
+ [rand(2)+6, rand(7), 3, :down],
+ [rand(2)+8, rand(8), 2, :down]
+ ]
+ end
+ end
+
+ def take_turn(state, ships_remaining)
+ @aim.test(state)
+ end
+end
+
+class Aim
+ attr_accessor :x, :y
+
+ def initialize
+ @x = -1
+ @x_speed = 1
+ @y = 0
+ @y_speed = 0
+ @right_border = 9
+ @left_border = 0
+ @top_border = 0
+ @bottom_border = 9
+
+ end
+
+ def test(state)
+ if @x >= @right_border && @x_speed == 1
+ @x = @right_border
+ @x_speed = 0
+ @y_speed = 1
+ @top_border += 1
+ end
+ if @y >= @bottom_border && @y_speed == 1
+ @y = @bottom_border
+ @x_speed = -1
+ @y_speed = 0
+ @right_border -= 1
+ end
+ if @x <= @left_border && @x_speed == -1
+ @x = @left_border
+ @x_speed = 0
+ @y_speed = -1
+ @bottom_border -= 1
+ end
+ if @y <= @top_border && @y_speed == -1
+ @y = @top_border
+ @x_speed = 1
+ @y_speed = 0
+ @left_border += 1
+ end
+
+ @x += @x_speed
+ @y += @y_speed
+ [@x,@y]
+ end
+end
View
182 contestants/iprug/death_bones_dan_player.rb
@@ -0,0 +1,182 @@
+class DeathBonesDanPlayer
+
+ def initialize
+ @taken_positions = []
+ @positions = []
+
+ @shots = []
+ end
+
+ def log(message)
+ File.open('debug.log', 'a') { |f| f.write("#{Time.now} - #{message}\n") }
+ end
+
+ def init_taken
+ (0..9).each do |x|
+ @taken_positions[x] = []
+ (0..9).each do |y|
+ @taken_positions[x][y] = 0
+ end
+ end
+ end
+
+ def print_grid
+
+ end
+
+ def reserve_position (x,y,length,orientation)
+
+ if orientation == :across
+ (x..length).each do |p|
+ @taken_positions[p][y] = 1
+ end
+ else
+ (y..length).each do |p|
+ @taken_positions[x][p] = 1
+ end
+ end
+
+ end
+
+ def has_space (x,y,length,orientation)
+
+ if orientation == :across
+ (x..length).each do |p|
+ return false if @taken_positions[p][y] == 1
+ end
+ else
+ (y..length).each do |p|
+ return false if @taken_positions[x][p] = 1
+ end
+ end
+
+ true
+
+ end
+
+ def generate_player_positions
+
+ # initialise taken grid
+ init_taken
+
+ ship_lengths = [5,4,3,3,2]
+
+ ship_lengths.each do |z|
+
+ upperbound = (10 - z)
+
+ # upperbound = (10 - z)
+
+ x = rand(upperbound)
+ y = rand(upperbound)
+
+ orientation = :across
+
+ placed = false
+
+ while !placed
+
+ orientation = orientation == :across ? :down : :across
+
+ x = rand(upperbound)
+ y = rand(upperbound)
+
+ # check ship position
+ if has_space(x,y,z,orientation)
+
+ @positions << [x,y,z,orientation]
+ reserve_position x,y,z,orientation
+
+ placed = true
+
+ end
+
+ end
+
+ end
+
+ log @positions.inspect
+
+ @positions
+
+ end
+
+ def generate_static_positions
+
+ [
+ [0, 0, 5, :across],
+ [0, 1, 4, :across],
+ [0, 2, 3, :across],
+ [0, 3, 3, :across],
+ [0, 4, 2, :across]
+ ]
+
+ end
+
+ # battleship methods
+
+ def name
+ "Death Bones Dan"
+ end
+
+ def new_game
+ generate_player_positions
+ #generate_static_positions
+ end
+
+ def take_turn(state, ships_remaining)
+
+ last_was_hit = false
+ last_shot = []
+
+ # check on last shot
+ if @shots.length > 0
+ last_shot = @shots.last
+ log "last: #{last_shot.inspect}"
+ last_was_hit = state[last_shot[1]][last_shot[0]] == :hit
+ end
+
+ if !last_was_hit
+
+ shot_x = rand(10)
+ shot_y = rand(10)
+
+ until state[shot_y][shot_x] == :unknown
+ shot_x = rand(10)
+ shot_y = rand(10)
+ end
+
+ else
+
+ shot_x = rand(10)
+ shot_y = rand(10)
+
+ until state[shot_y][shot_x] == :unknown
+ shot_x = rand(10)
+ shot_y = rand(10)
+ end
+
+ # last_x_u = last_shot[0] + 2
+ # last_y_u = last_shot[1] + 2
+ #
+ # last_x_l = last_shot[0] - 2
+ # last_y_l = last_shot[1] - 2
+ #
+ # shot_x = last_x_l + rand(last_x_u + 1 - last_x_l)
+ # shot_y = last_x_l + rand(last_y_u + 1 - last_y_l)
+ #
+ # until state[shot_y][shot_x] == :unknown
+ # shot_x = last_x_l + rand(last_x_u + 1 - last_x_l)
+ # shot_y = last_x_l + rand(last_y_u + 1 - last_y_l)
+ # end
+
+ end
+
+ log "Shooting at #{shot_x}, #{shot_y}"
+
+ @shots << [shot_x, shot_y]
+
+ [shot_x, shot_y]
+ end
+
+end
View
80 contestants/iprug/graham_player.rb
@@ -0,0 +1,80 @@
+class GrahamPlayer
+ def initialize
+ @x=0
+ @y=0
+ @advance = 3
+ @last_turn = []
+ @on_a_roll = false
+ @direction_forward = true
+ end
+
+ def name
+ "Graham Hadgraft"
+ end
+
+ def new_game
+ [
+ [rand(5), 0, 5, :across],
+ [rand(6), 4, 4, :across],
+ [rand(7), 5, 3, :across],
+ [rand(7), 6, 3, :across],
+ [rand(8), 8, 2, :across]
+ ]
+ end
+
+ def take_turn(state, ships_remaining)
+ if @last_turn[0] != nil && last_turn(state) == :hit
+ @x += 1
+ @on_a_roll = true
+ elsif @last_turn[0] != nil && @on_a_roll == true && last_turn(state) == :miss
+ @x -= 2
+ @on_a_roll = false
+
+ else
+ @x += @advance
+ end
+
+ check_valid_coords(@x, @y)
+ check_if_shot(@x,@y, state)
+
+ @last_turn = [@x, @y]
+
+ end
+
+ private
+ def last_turn(state)
+ state[@last_turn[1]][@last_turn[0]]
+ end
+
+ def check_valid_coords(x,y)
+ if @x > 9
+ @x -= 10
+ @y += 1
+ end
+
+ if @y > 9
+ @y=0
+ end
+ end
+
+ def check_if_shot (x, y, state)
+ while state[y][x] == :miss || state[y][x] == :hit
+ if @direction_forward == true
+ x += 1
+ else
+ x -= 1
+ end
+
+ if x > 9
+ x -= 10
+ y += 1
+ end
+
+ if y > 9
+ y=0
+ end
+ @x = x
+ @y = y
+ end
+ end
+end
View
95 contestants/iprug/kerry_player.rb
@@ -0,0 +1,95 @@
+module Randomiser
+ class << self
+ def coordinate
+ rand 10
+ end
+
+ def start_of_ship_with_length length
+ rand(10 - length)
+ end
+
+ def direction
+ [:across, :down][rand(2)]
+ end
+ end
+end
+
+class ShipPlacer
+ def initialize
+ @taken = []
+ end
+
+ def carrier
+ ship_of_length 5
+ end
+
+ def battleship
+ ship_of_length 4
+ end
+
+ def sub
+ ship_of_length 3
+ end
+
+ def cruiser
+ ship_of_length 3
+ end
+
+ def destroyer
+ ship_of_length 2
+ end
+
+ private
+
+ def ship_of_length length
+ direction = Randomiser.direction
+ across_coord = Randomiser.coordinate
+ along_coord = Randomiser.start_of_ship_with_length length
+ try_again = false
+ taken = @taken
+ if direction == :across
+ x, y = along_coord, across_coord
+ (y..y+length).each do |y|
+ try_again ||= @taken.include? [x, y]
+ @taken << [x, y]
+ end
+ else
+ x, y = across_coord, along_coord
+ (x..x+length).each do |x|
+ try_again ||= @taken.include? [x, y]
+ @taken << [x, y]
+ end
+ end
+ if try_again
+ ship_of_length(length)
+ else
+ @taken = taken
+ [x, y, length, direction]
+ end
+ end
+end
+
+class KerryPlayer
+ def initialize
+ @tried = []
+ end
+
+ def name
+ "Kerry"
+ end
+
+ def new_game
+ placer = ShipPlacer.new
+ [placer.carrier, placer.battleship, placer.sub, placer.cruiser, placer.destroyer]
+ end
+
+ def take_turn state, ships_remaining
+ x, y = Randomiser.coordinate, Randomiser.coordinate
+ if @tried.include? [x, y]
+ take_turn state, ships_remaining
+ else
+ @tried << [x, y]
+ [x, y]
+ end
+ end
+end
View
209 contestants/iprug/matthewR.rb
@@ -0,0 +1,209 @@
+class MatthewRPlayer
+ def initialize
+ @state = Array.new(10) { Array.new(10,:unknown) }
+ @last_coords = nil
+ @hits_list = []
+ @last_ships = []
+ @unalloc_sunk_len = 0
+ @last_deltas = nil
+ end
+
+ def name
+ "Matthew Robinson"
+ end
+
+ def new_game
+ # top secret info. Ideally replace with a random choice (and/or try and make use of the probabilities)
+
+ #[ [0,4,5, :down], [2,9,4, :across], [9,7,3, :down], [5,6,3, :across], [5,7,2, :down]]
+ @state = Array.new(10) { Array.new(10,:unknown) }
+ ship_lengths = [5,4,3,3,2]
+ ship_lengths.map do |len|
+ x,y,orient = nil
+ loop do
+ x=rand(10)
+ y=rand(10)
+ orient = (rand(2) == 1) ? :down : :across
+ break if ship_fits?(x,y,len,orient)
+ end
+ record_ship(x,y,len,orient)
+ [x,y,len,orient]
+ end
+ end
+
+ def state_at(coords)
+ # return the state at this co-ordinate
+ # if co-ordinates are outside the grid return a default value of :miss
+
+ x=coords[0]
+ y=coords[1]
+ if (0..9) === x and (0..9) === y
+ return @state[y][x]
+ else
+ return :miss
+ end
+ end
+
+ def apply_ship(len)
+ counts = Array.new(10) { Array.new(10,0) }
+ [:down, :across].each do |orient|
+ 0.upto(9) do |x|
+ 0.upto(9) do |y|
+ if ship_fits?(x,y,len,orient)
+ 0.upto(len-1) do |delta|
+ if orient == :down
+ counts[y+delta][x]+=1
+ elsif orient == :across
+ counts[y][x+delta]+=1
+ end
+ end
+ end
+ end
+ end
+ end
+ return counts
+ end
+
+ def ship_fits?(x,y,len,orient)
+ fits=true
+ 0.upto(len-1) do |delta|
+ if orient == :down
+ fits &= state_at([x,y+delta])==:unknown
+ elsif orient == :across
+ fits &= state_at([x+delta,y])==:unknown
+ end
+ end
+ fits
+ end
+
+ def record_ship(x,y,len,orient)
+ 0.upto(len-1) do |delta|
+ if orient == :down
+ @state[y+delta][x]= :ship
+ elsif orient == :across
+ @state[y][x+delta]= :ship
+ end
+ end
+ end
+
+ def total_count(counts)
+ counts.inject(0) do |acc,row|
+ acc + row.inject { |a,b| a+b }
+ end
+ end
+
+ def normalise(counts,len)
+ total = total_count(counts)
+ factor = (total>0) ? (len * 1.0 / total) : 0
+
+ counts.map do |row|
+ row.map do |value|
+ value * factor
+ end
+ end
+ end
+
+ def sum_counts(counts_arrays)
+ results = Array.new(10) { Array.new(10,0) }
+
+ counts_arrays.each do |counts|
+
+ 0.upto(9) do |x|
+ 0.upto(9) do |y|
+ results[y][x] = (results[y][x]) + (counts[y][x])
+ end
+ end
+ end
+ return results
+ end
+
+ def try_coords(coords)
+ #either return the co-ordinates if a valid move or else nil
+ state_at(coords) == :unknown ? coords : nil
+ end
+
+ def sum_coords(a,b)
+ # return sum of two co-ordinates
+ x = a[0] + b[0]
+ y = a[1] + b[1]
+ [x,y]
+ end
+
+ def coords_of_max(grid)
+ #return the [x,y] coords of the square with highest value
+
+ m =-1
+ x_of_max =-1
+ y_of_max =-1
+
+ 0.upto(9) do |x|
+ 0.upto(9) do |y|
+ if grid[y][x] > m
+ m=grid[y][x]
+ x_of_max = x
+ y_of_max = y
+ end
+ end
+ end
+
+ [x_of_max, y_of_max]
+ end
+
+
+ def find_ships(ships_remaining)
+ # return the square with the highest probability of hitting a ship
+
+ probabilities_per_ship = ships_remaining.map do |ship_len|
+ normalise(apply_ship(ship_len), ship_len)
+ end
+
+ coords_of_max(sum_counts(probabilities_per_ship))
+ end
+
+ def take_turn(state, ships_remaining)
+ @state = state
+
+ shot=nil
+
+ unless @last_coords.nil?
+ #see what happened with our previous shot
+ if state_at(@last_coords) == :hit
+ @hits_list << @last_coords
+ if @last_ships.length > ships_remaining.length
+ #we sunk a ship so work out which one
+ sunk_len = (@last_ships - ships_remaining).last
+ sunk_len ||= 3 # fix for length 3 ships (as we may have sunk first one and still have a len 3 ship in both lists)
+ @unalloc_sunk_len += sunk_len
+ if @hits_list.length == @unalloc_sunk_len
+ #all hits are due to these ship(s), so no need to search further
+ @hits_list = []
+ @unalloc_sunk_len =0
+ end
+ else
+ if @hits_list.length > 1
+ #try carrying on in same direction
+ shot = try_coords(sum_coords(@last_coords, @last_deltas))
+ end
+ end
+ end
+
+ #if we haven't yet found a square, try searching around existing hits
+ if shot.nil?
+ @hits_list.each do |hit|
+ [[1,0], [-1,0], [0,1], [0,-1]].each do |deltas|
+ @last_deltas = deltas if shot.nil?
+ shot ||= try_coords(sum_coords(hit, deltas))
+ end
+ end
+ end
+ end
+
+ shot ||= find_ships(ships_remaining) #if nothing better to do, then open up a new area of the board
+
+ #store relevant state
+ @last_coords= shot
+ @last_ships=ships_remaining.dup
+ shot # return the shot we want to take
+ end
+
+end #end of class
View
114 contestants/iprug/matthew_bennett.rb
@@ -0,0 +1,114 @@
+def out(*args)
+ puts *args
+end
+
+class Array
+ def delta(arr)
+ [self[0] + arr[0], self[1] + arr[1]]
+ end
+
+ def outside(lower, upper)
+ self[0] < lower[0] || self[1] < lower[1] || self[0] > upper[0] || self[1] > upper[1]
+ end
+end
+
+class UndecisivePlayer
+ def name
+ "@undecisive (Matthew Bennett)"
+ end
+
+ def new_game
+ @previous_moves = []
+ random_starting_positions
+ end
+
+ def take_turn(state, ships_remaining)
+ out "Taking turn..."
+ begin
+ if @real_shot && hit?(@latest_attempt, state)
+ out "HIT! #{@latest_attempt.inspect}"
+ @surroundings = false
+ @first_hit ||= @latest_attempt
+ @latest_good_attempt = @latest_attempt
+ @latest_attempt = try_a_surrounder
+ elsif(@latest_good_attempt)
+ out "Found a good shot...."
+ @latest_attempt = try_a_surrounder
+ else
+ @latest_attempt = random_shot
+ end
+ @real_shot = false
+ @real_shot = true unless @previous_moves.include? @latest_attempt
+ end until @real_shot
+ @previous_moves << @latest_attempt
+ @latest_attempt
+ end
+
+ private
+ def hit?(attempt, state)
+ return false if attempt.nil?
+ state[ attempt[1] ][ attempt[0] ] == :hit
+ end
+
+ def reset
+ out "resetting..."
+ @latest_attempt = nil
+ @latest_good_attempt = nil
+ @surroundings = []
+ end
+
+ def try_a_surrounder
+ out "Surrounding... #{@surroundings.inspect}"
+ @surroundings ||= []
+ if @surroundings.length >= 4
+ reset
+ if(@first_hit)
+ @latest_good_attempt = @first_hit
+ @first_hit = nil
+ #return random_shot
+ return try_a_surrounder
+ else
+ return random_shot
+ end
+ return random_shot
+ end
+
+ begin
+ @surroundings << @latest_good_attempt.delta(surround_addition(@surroundings.length))
+ end until within_bounds?(@surroundings.last)
+
+ @surroundings.last
+ end
+
+ def within_bounds?(shot)
+ !shot.outside([0,0], [9,9])
+ end
+
+ def random_shot
+ @first_hit = nil
+ [rand(10), rand(10)]
+ end
+
+ def surround_addition(num)
+ case num % 4
+ when 0
+ [-1,0]
+ when 1
+ [0,-1]
+ when 2
+ [1,0]
+ when 3
+ [0,1]
+ end
+ end
+
+ def random_starting_positions
+ [
+ [0, 0, 5, :across],
+ [2, 2, 4, :across],
+ [4, 3, 3, :across],
+ [5, 5, 3, :across],
+ [8, 7, 2, :across]
+ ]
+ end
+end
View
112 contestants/iprug/mega_ship_fucker.rb
@@ -0,0 +1,112 @@
+module MSF
+ class Board
+
+ NEIGHBOURS = [[0, -1], [1, 0], [0, 1], [-1, 0]]
+
+ Point = Struct.new(:row, :column, :probability)
+
+ def initialize
+ @sunk_ships = []
+ @last_ships_remaining = [5, 4, 3, 3, 2]
+ @saved_move = nil
+ end
+
+ def update(state, ships_remaining)
+ if @last_ships_remaining != ships_remaining
+ @sunk_ships << ship_sunk((@last_ships_remaining - ships_remaining).first)
+ end
+ @state = state
+ @ships_remaining = ships_remaining
+ end
+
+ def make_move
+ squares = free_squares
+ squares = set_probabilities(squares)
+ squares = top_probs(squares)
+ #if squares.first.probability == 0
+ #squares.each { |s| s.probability = ((s.row) % 2) * (s.column % 2) }
+ #squares = top_probs(squares)
+ #end
+ @saved_move = squares[rand(squares.size)]
+ [@saved_move.row, @saved_move.column]
+ end
+
+ private
+
+ def ship_sunk(size)
+
+ end
+
+ def free_squares
+ squares = []
+ puts @state.inspect
+ @state.each_with_index do |row, column_index|
+ row.each_with_index do |value, row_index|
+ squares << Point.new(row_index, column_index, 0) if value == :unknown
+ end
+ end
+ squares
+ end
+
+ def set_probabilities(squares)
+ squares.each do |square|
+ square.probability = neighbour_hit_count(square)
+ end
+ squares
+ end
+
+ def neighbour_hit_count(square)
+ count = 0
+ NEIGHBOURS.each do |dy, dx|
+ if value_at(square.row + dx, square.column + dy) == :hit
+ if value_at(square.row + (dx * 2), square.column + (dy * 2)) == :hit
+ count += 5
+ else
+ if value_at(square.row + (dx * 3), square.column + (dy * 3)) == :hit
+ count += 3
+ else
+ count += 1
+ end
+ end
+ end
+ #count += 1 if value_at(square.row + dx, square.column + dy) == :hit
+ end
+ count
+ end
+
+ def top_probs(squares)
+ sorted = squares.sort { |a, b| b.probability <=> a.probability }
+ top = sorted.first
+ sorted.reject { |s| s.probability < top.probability }
+ end
+
+ def value_at(row, column)
+ return :unknown unless @state[column]
+ @state[column][row]
+ end
+ end
+end
+
+class MeggaShipFuckerPlayer
+
+ START_BOARDS = [
+ [[4, 1, 5, :down], [2, 9, 4, :across], [6, 2, 3, :down], [0, 1, 3, :down], [9, 7, 2, :down]],
+ [[1, 4, 5, :across], [9, 2, 4, :down], [2, 6, 3, :across], [1, 0, 3, :across], [7, 9, 2, :across]],
+ [[1, 1, 5, :down], [6, 3, 4, :across], [4, 2, 3, :down], [5, 7, 3, :across], [3, 6, 2, :down]],
+ ]
+
+ def name
+ "Megga Ship Fucker - ve eatz your shipz"
+ end
+
+ def new_game
+ @board = MSF::Board.new
+ START_BOARDS[rand(START_BOARDS.size)]
+ end
+
+ def take_turn(state, ships_remaining)
+ @board.update(state, ships_remaining)
+ @board.make_move
+ end
+end
+
View
154 contestants/iprug/mrjaba_player.rb
@@ -0,0 +1,154 @@
+class Cluster
+ def initialize(on)
+ @x, @y = on
+ end
+
+ def neighbours
+ [[1,0],[0,-1],[-1,0],[0,1]].collect do |dx, dy|
+ [@x + dx, @y+dy]
+ end.select{ |x,y| x >= 0 && y >= 0 && x < 10 && y < 10 }
+ end
+end
+
+class ClusterFire
+ def initialize(cluster, shots)
+ @cluster = cluster
+ @shots = shots
+ @queue = @cluster.neighbours.select{|shot| !@shots.include?(shot)}
+ end
+
+ def all
+ @queue
+ end
+end
+
+class RandomFire
+
+ def next(shots)
+ loop do
+ tmp_shot = [rand(10), rand(10)]
+ return tmp_shot if !shots.include?(tmp_shot)
+ end
+ end
+
+end
+
+class PatternFire
+ def initialize
+ @x, @y = 9, 4
+ @mode = :horizontal
+ @pattern_shots = []
+ @random_fire = RandomFire.new
+ end
+
+ def next(shots)
+ if @mode == :horizontal
+ @pattern_shots << [@x, @y]
+ @x -= 1
+ @y = @y == 4 ? 6 : 4
+ end
+ if @mode == :vertical
+ @pattern_shots << [@x, @y]
+ @y += 1
+ @x = @x == 4 ? 6 : 4
+ end
+ if @mode == :horizontal && @x == -1
+ @mode = :vertical
+ @x = 4
+ @y = 0
+ end
+ if @mode == :fill
+ @pattern_shots << [@x, @y]
+ @x += 2
+ if @x >= 9
+ @x = @y % 2 == 0 ? 1 : 0
+ @y += 1
+ end
+ end
+ if @mode == :vertical && @y == 9
+ @mode = :fill
+ @x = 0
+ @y = 1
+ end
+ if shots.include? @pattern_shots.last
+ @random_fire.next(shots)
+ else
+ @pattern_shots.last
+ end
+ end
+
+end
+
+class FiringSquad
+ def initialize
+ @random_fire = RandomFire.new
+ @pattern_fire = PatternFire.new
+ @cluster_shots = []
+ @shots = []
+ end
+
+ def shoot(board)
+ if should_pattern_fire?(board)
+ @shots << @pattern_fire.next(@shots)
+ elsif hit?(@shots.last, board)
+ @cluster_shots += ClusterFire.new(Cluster.new(@shots.last), @shots).all
+ @shots << @cluster_shots.pop
+ else
+ @shots << @cluster_shots.pop
+ end
+ if @shots.last.nil?
+ @shots << @random_fire.next(@shots)
+ @shots.last
+ else
+ @shots.last
+ end
+ end
+
+ def should_pattern_fire?(board)
+ @shots.empty? || miss?(@shots.last, board) && @cluster_shots.empty?
+ end
+
+ def miss?(shot, board)
+ board[shot[1]][shot[0]] != :hit
+ end
+
+ def hit?(shot, board)
+ if shot
+ board[shot[1]][shot[0]] == :hit
+ end
+ end
+
+end
+
+class MrjabaPlayer
+
+ def name
+ "Mrjaba Player"
+ end
+
+ def initialize
+ @ships = [5,4,3,3,2]
+ @firing_squad = FiringSquad.new
+ end
+
+ def new_game
+ position_ships
+ end
+
+ def take_turn(board, remaining_ships)
+ @firing_squad.shoot(board)
+ end
+
+ def position_ships
+ x = -1
+
+ @ships.collect do |ship|
+ x +=2
+ top = rand(100) <= 50
+ y = top ? 1 : 10 - ship
+ [x, y, ship, :down]
+ end
+ end
+
+end
+
Please sign in to comment.
Something went wrong with that request. Please try again.