Vfrdtyky

I need to implement a move method that change position according to facing, position is a [x,y] and I thinking that if move to south is y+1, to north y-1, to east x-1 and to west x+1. this movements are into a matrix.
This is my code. Thank you so much for your help!

# Models the Robot behavior for the game

class Robot

 FACINGS = [:south, :east, :north, :west]



 def initialize(attr = {})

  @position = attr[:position] || [1, 1]

  # @move = attr[:move]

  @facing_index = facing_index(attr[:facing]) || 0 # south

  @facing = facing

  # @errors =

 end



 def position

  @position

 end



 def move



 end



 def facing

  @facing = FACINGS[@facing_index]

 end



 def errors

 end



 private



 def facing_index(facing)

  facing if facing.is_a? Integer

  FACINGS.index(facing&.to_sym)

 end

end

DIRECTION_NUMBER = { :north=>0, :east=>1, :south=>2, :west=>3 }



@left = { :north=>:west, :west=>:south, :south=>:east, :east=>:north }

@right = @left.invert

  #=> {:west=>:north, :south=>:west, :east=>:south, :north=>:east}



def turn_left

  @facing = @left[@facing]

end



def turn_right

  @facing = @right[@facing]

end



def move(direction)

  x, y = @location

  @location =

  case direction

  when :north

    [x,y+1]

  when :east

    [x+1,y]

  when :south

    [x,y-1]

  else

    [x-1,y]

  end

  update_facing(direction)

end

private



def update_facing(direction)

  change = (DIRECTION_NUMBER[direction] - DIRECTION_NUMBER[@facing]) % 4

  case change

  when 1

    turn_right

  when 2

    turn_right; turn_right

  when 3

    turn_left

  end

end

@location = [3, 3]    

@facing = :east



move(:south)

@location   #=> [3, 2]

@facing     #=> :south



move(:north)

@location   #=> [3, 3]

@facing     #=> :north



move(:west)

@location   #=> [2, 3]

@facing     #=> :west



move(:east)

@location   #=> [3, 3]

@facing     #=> :east

Add MOVES which says how to move based on how you're facing.

MOVES = {

  north: [0, 1],

  south: [0, -1],

  east:  [1, 0],

  west:  [-1,0]

}



def move

  move = MOVES.fetch(@facing)

  @position[0] += move[0]

  @position[1] += move[1]

end

MOVES.fetch(@facing) is used instead of MOVES[@facing] so an error will be raised if there is no move for that facing.

You could also do this with a case statement, but this keeps move simple and data driven. You can add more directions like northeast: [1,1]. And if you make this an instance variable, you can customize how individual robots move.

# Define `moves` and `moves=` to get and set `@moves`

attr_accessor :moves



def initialize(attr = {})

  ...

  # Initialize `moves` with either Robot.new(moves: {...})

  # or the default MOVES

  @moves ||= attr[:moves] || MOVES

  ...

end



def move

  move = moves.fetch(@facing)

  @position[0] += move[0]

  @position[1] += move[1]

end

FACINGS enum example.

module FACINGS

  NORTH = [0, 1]

  SOURTH = [0, -1]

  EAST =  [1, 0]

  WEST =  [-1,0]

end



class Robot

  attr_reader :position



  def initialize(attr = {})

    @position = attr[:position] || [1, 1]

  end



  def move(facings)

    @position[0] += facings[0]

    @position[1] += facings[1]

  end

end



r = Robot.new

r.move(FACINGS::NORTH)

r.move(FACINGS::SOURTH)

r.move(FACINGS::WEST)

r.move(FACINGS::EAST)