why when I call a function passing a reference to an array, the array is changing in ruby?

I was following a tutorial on creating a little game in Ruby when I fell into a bug I couldn't understand. When I looked closely, I realized that the error was happening in line 51 of the fogefoge.rb on the call of nova_posicao = calcula_nova_posicao heroi, direcao.<br><br>
At this point of the tutorial, the heroe "H" should be able to move around with the keys "ASDW". I noticed that the array heroi at line 49 heroi = encontra_jogador mapa has been changed and that was introducing the bug in the application. After that I created another variable called heroi2 and the code worked.<br><br>
Why when I call line 51 of fogefoge.rb, the array is changing?<br><br>
From what I've been reading in Rubydocs, I just can't understand why this is happening.

File "main.rb"
require_relative "fogefoge"
inicia_fogefoge

File "mapa1.txt"
XXXXX
X H X
X X X
X X X
X   X
X  
XXX 
X  
X F X
XXXXX

File "ui.rb"
def da_boas_vindas
puts "bem vindo ao Foge-foge"
puts "Qual é o seu nome?"
nome = gets.strip
puts "\n\n\n\n\n"
puts "Começaremos o jogo para você, #{nome}"
nome
end
def desenha(mapa)
puts mapa
end
def pede_movimento
puts "Para onde deseja ir?"
movimento = gets.strip
end

#File "fogefoge.rb"
require_relative "ui"
def le_mapa(numero)
arquivo = "mapa#{numero}.txt"
texto = File.read(arquivo)
mapa = texto.split "\n"
#  p mapa
end
def encontra_jogador(mapa)
caractere_do_heroi = "H"
mapa.each_with_index do |linha_atual, linha|
coluna_do_heroi   = linha_atual.index caractere_do_heroi
if coluna_do_heroi
return [linha, coluna_do_heroi]
end
end
end
def calcula_nova_posicao(heroi, direcao)
case direcao
when "W"
heroi[0] -= 1
when "S"
heroi[0] += 1
when "A"
heroi[1] -= 1
when "D"
heroi[1] += 1
end
heroi
end
def posicao_valida?(mapa, posicao)
linhas = mapa.size
colunas = mapa[0].size
estourou_linhas = posicao[0] < 0 || posicao[0] >= linhas
estourou_colunas = posicao[1] < 0 || posicao[1] >= colunas
if estourou_linhas || estourou_colunas
return false
end
if mapa[posicao[0]][posicao[1]] == "X"
return false
end
true
end
def joga(nome)
mapa = le_mapa 1
while true
desenha mapa
direcao = pede_movimento
heroi = encontra_jogador mapa
#heroi2 = encontra_jogador mapa
nova_posicao = calcula_nova_posicao heroi, direcao #At this call
if !posicao_valida? mapa, nova_posicao
next
end
mapa[heroi[0]][heroi[1]] = " "
mapa[nova_posicao[0]][nova_posicao[1]] = "H"
end
end
def inicia_fogefoge
nome = da_boas_vindas
joga nome
end

I was expecting that the "H" would move around through the blank spaces, but the "H" was repeated to a few directions<br><br>
<br>
OUTPUT:
<br>

bem vindo ao Foge-foge
Qual é o seu nome?
marcos
Começaremos o jogo para você, marcos
XXXXX
X H X
X X X
X X X
X   X
X  
XXX 
X  
X F X
XXXXX
Para onde deseja ir?
d
XXXXX
X H X
X X X
X X X
X   X
X  
XXX 
X  
X F X
XXXXX
Para onde deseja ir?
D
XXXXX
X HHX
X X X
X X X
X   X
X  
XXX 
X  
X F X
XXXXX
Para onde deseja ir?
S
XXXXX
X HHX
X X X
X X X
X   X
X  
XXX 
X  
X F X

if you uncomment the second reference at line 50 and then change line 51 to nova_posicao = calcula_nova_posicao heroi2, direcao then the code work.

Your calcula_nova_posicao implementation alters the passed heroi array and then returns it. Therefore, your nova_posicao and heroi will be the same after the call (not only containing the same values, but both referring to the very same object).

Here's a quick example on how to verify this: (equal? checks if two objects are in fact the same object)

a = [0, 0]
b = calcula_nova_posicao(a, "S")
a #=> [1, 0]  <- note that "a" has changed!
b #=> [1, 0]
a.equal?(b) #=> true

> why when I call a function passing a reference to an array, the array is changing in ruby?

This is a very fundamental behavior in Ruby. Some objects are mutable, i.e. you can alter such objects by sending certain messages to them (so-called destructive methods). Examples of mutable objects are strings, hashes and arrays. It doesn't matter how or where the (destructive) message is sent or who sends it. Once received, the object will alter itself.

Here's an example of two variables a and b referring to the same object, a string. If you send the upcase! message to the string, it will upcase its characters and both variables will reflect that change: (because they are still referring to the same object which now has changed)

a = "foo"
b = a
a.upcase!   # or b.upcase!
a #=> "FOO"
b #=> "FOO"

The same applies to method arguments. If you pass a mutable object into a method, the method can alter it, just like you can outside the method:

def my_method(s)
s.upcase!
end
a = "foo"
my_method(a)
a #=> "FOO"

Back to your problem. You probably want calcula_nova_posicao to 1) return a new array and 2) leave the passed-in array unchanged. The latter is important to clear the current H from the map. But it's also a good idea in general to not change arguments within methods because it can lead to unexpected results and hard to find bugs.

Here's one implementation:

def calcula_nova_posicao(heroi, direcao)
case direcao
when "W"
[heroi[0] - 1, heroi[1]]
when "S"
[heroi[0] + 1, heroi[1]]
when "A"
[heroi[0], heroi[1] - 1]
when "D"
[heroi[0], heroi[1] + 1]
end
end

Here's another one using array decomposition:

def calcula_nova_posicao(heroi, direcao)
y, x = heroi
case direcao
when "W" then y -= 1
when "S" then y += 1
when "A" then x -= 1
when "D" then x += 1
end
[y, x]
end

You might consider writing tests for your methods.