ruby - 解析康威的游戏网格

Question

这是我尝试用 Ruby 编写康威的生命游戏 (http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life#Rules)。

我有一个关于“count_neighbours”方法的非常具体的问题。基本上，当我到达网格的边缘时，我会出现一些奇怪的行为。当我解析第 0 行并到达最后一列(Cloumn 4)时，它会执行如下操作:

评估单元格:R:0 C:4

• 评估邻居 R:-1 C:3。状态:0
• 评估邻居 R:-1 C:4。状态:1
• 评估邻居 R:-1 C:5。状态:
• 评估邻居 R:0 C:3。状态:0
• 评估邻居 R:0 C:5。状态:
• 评估邻居 R:1 C:3。状态:1
• 评估邻居 R:1 C:4。状态:0
• 评估邻居 R:1 C:5。状态:

一个好处是“R: -1”基本上将计算环绕到网格的底部，就好像网格的边缘真的相连一样。我喜欢无边网格的想法。

这里的坏处是该方法试图评估不存在的“C: 5”(第 5 列)，因为在此示例中，网格是第 0-4 列。所以这是我寻求帮助解决的第一个问题。理想情况下，我想在这里评估第 0 列。

下一个问题是当该方法尝试计算网格上的最后一行，即第 4 行时。当该方法尝试计算“R: 5”时会抛出一个错误。错误是“undefined method `[ ]' for nil:NilClass (NoMethodError)”，因为该行不存在。为了避免抛出错误，我在评论“#This line is a hack”下方添加了一行，但我希望能够在没有错误的情况下评估这一行。

我的最后一个问题是，为什么超出最后一行到第 5 行会抛出错误，而超出最后一列不会抛出错误？

    #Dimensions for the game grid
    WIDTH = 5
    HEIGHT = 5

    def rand_cell
      rand(2)
    end

    def starting_grid
      #Initialise the playing grid
      @start_grid = Array.new(WIDTH){Array.new(HEIGHT)}
      #Randomly generate starting state for each cell on the grid
      @start_grid.each_with_index do |row, rindex|
        row.each_with_index do |col, cindex|
          @start_grid[rindex][cindex] = rand_cell
        end
      end
    end

    def next_grid
      #build the next generation's grid to load values into
      @next_gen_grid = Array.new(WIDTH){Array.new(HEIGHT)}

      #parse each cell in the start grid to see if it lives in the next round
      @start_grid.each_with_index do |row, rindex|
        row.each_with_index do |col, cindex|
          puts "\n\nEvaluating cell: R: #{rindex} C: #{cindex}"
          @next_gen_grid[rindex][cindex] = will_cell_survive(rindex, cindex)
        end
      end   
      #move the newly generated grid to the start grid as a sterting point for the next round
      @start_grid = @next_gen_grid
    end

    def show_grid(grid)
      #Display the evolving cell structures in the console
      grid.each_with_index do |row, rindex|
        row.each_with_index do |col, cindex|
          if grid[rindex][cindex] == 1
            print "️⬛️ "
          else
            print "⬜️ ️"
      end  
    end
    puts "\n"
  end
end

def count_neighbours(row, col)
  cell_count = 0
  rows = [-1, 0, 1]
  cols = [-1, 0, 1]

  rows.each do |r|
    cols.each do |c|
      #ingnore the cell being evaluated
      unless c == 0 && r == 0

        #This line is a hack to stop an error when evaluating beyond the last row
        if  row != HEIGHT-1
          puts "Evaluating neighbor R: #{row+r} C: #{col+c}. State: #{@start_grid[(row+r)][(col+c)]}" 
          if @start_grid[(row+r)][(col+c)] == 1
            cell_count += 1
          end
        end

      end
    end
  end
  puts "Neighbour count is #{cell_count}"
  return cell_count
end

def will_cell_survive(rindex, cindex)
  count = count_neighbours(rindex, cindex)
  #If the cell being evaluated is currently alive
  if @start_grid[rindex][cindex] == 1
       #test rule 1 
    if alive_rule1(count)
      puts "Rule 1"
      return 0
          #test rule 2
    elsif alive_rule2(count)
      puts "Rule 2"
      return 1
    elsif
      #test rule 3
      puts "Rule 3"
      return 0
    end

  #If the cell being evaluated is currently dead      
  else
    #test rule 4
    alive_rule4(count)
      puts "Rule 4"
      return 1
  end
end

def alive_rule1(neighbour_count)
    neighbour_count < 2
end

def alive_rule2(neighbour_count)
  neighbour_count == 2 || neighbour_count == 3
end

def alive_rule3(neighbour_count)
  neighbour_count > 3
end

def alive_rule4(neighbour_count)
  neighbour_count == 3
end


#Run just one round of the game
system "clear"
starting_grid
show_grid(@start_grid)
puts "\n\n" 
next_grid
show_grid(@next_gen_grid)


#Initiate the game grid
#   system "clear"
#   starting_grid

#Run the game
# 200.times do |t|
#   system "clear"
#   puts "\n\n" 
#   next_grid
#   puts "Grid #{t}"
#   show_grid(@next_gen_grid)
#   sleep(0.25)
# end

[编辑]:实现答案的代码位于 https://github.com/AxleMaxGit/ruby-conways-game。

Answer 1

如果你想将边缘相互连接(顺便创建一个“圆环”形状，或者如果你更喜欢“小行星”世界模型，你永远不会离开屏幕)那么最简单的调整是在模块化算法中工作:

改变:

if @start_grid[(row+r)][(col+c)] == 1

收件人:

if @start_grid[(row+r) % HEIGHT][(col+c) % WIDTH] == 1

运算符符号 % 是模运算，可根据您的需要精确执行环绕逻辑。

超出最后一行与超出最后一列的行为不同的原因是:

@start_grid[ 3 ][ 5 ] == nil

它在您对邻居的检查中返回 false，其他一切正常。

但是，

@start_grid[ 5 ][ 3 ]

是一个问题，因为@start_grid[5]是nil，所以它是有效的

nil[ 3 ]

错误被抛出是因为 Ruby 没有解析 [] 在 nil 上的含义的逻辑。