Ruby 康威'；有逻辑问题的人生游戏

我在写康威的《生活游戏》。我有一些逻辑问题，它总是在2或3个刻度（通常只有2个刻度）内完成。大多数情况下，所有细胞都已死亡，但偶尔也会有1或2个细胞仍然存活。我找不到是什么原因导致第二只蜱的行为几乎完全（如果不是完全）死亡

你们中有人看到可能导致这种行为的任何重大问题吗

require 'pry'
class Game
  def initialize(size)
    @size = size
    @ticks = 1
    @current_board = Array.new(size) { Array.new(size) { (rand(99) % 5 == 0) ? false : true } }
    @future_board = Array.new(size) { Array.new(size) }
    # @future_board = @current_board
  end

  def is_alive?(y, x)
    if @current_board[y]
      @current_board[y][x]
    end
  end

  def check_neigbors(y, x)
    neighbors = {
      top:          [y-1, x],
      top_right:    [y-1, x+1],
      right:        [y, x+1],
      bottom_right: [y+1, x+1],
      bottom:       [y+1, x],
      bottom_left:  [y+1, x-1],
      left:         [y, x-1],
      top_left:     [y-1, x-1]
    }
    neighbor_state = {
      top:          false,
      top_right:    false,
      right:        false,
      bottom_right: false,
      bottom:       false,
      bottom_left:  false,
      left:         false,
      top_left:     false
    }
    # binding.pry
    neighbors.each { |k, v| neighbor_state[k] = true if is_alive?(v[0], v[1]) }
    live_neighbor_count = 0
    neighbor_state.each_value { |v| live_neighbor_count += 1 if v }
    live_neighbor_count
  end

  def cell_lives(y, x)
    @future_board[y][x] = true
  end

  def cell_dies(y, x)
    @future_board[y][x] = false
  end

  def display_board
    # need to display board here
    system("clear")
    # @current_board.each do
    # |r| puts r.map { |c| c ? 'O' : 'X' }.join(" ")
    # |r| puts r.map { |c| c }.join(" ")
    puts @current_board.map { |row| row.map { |cell| cell ? 'X' : ' ' }.inspect }
    # end
    puts "\nTicks: #{@ticks}"
  end

  def play
    loop do
      display_board
      @current_board.each do |r| # outer loop to iterate through rows
        row_index = @current_board.index(r).to_i
        r.each do |c| # inner loop to iterate through columns
          column_index = r.index(c).to_i
          live_neighbor_count = check_neigbors(row_index, column_index) # count the number of live neighbors
          cell_dies(row_index, column_index) if ( is_alive?(row_index, column_index) ) && live_neighbor_count < 2 # rule 1
          cell_lives(row_index, column_index) if ( is_alive?(row_index, column_index) ) && ( live_neighbor_count == 2 || live_neighbor_count == 3 ) # rule 2
          cell_dies(row_index, column_index) if ( is_alive?(row_index, column_index) ) && live_neighbor_count > 3 # rule 3
          cell_lives(row_index, column_index) if !( is_alive?(row_index, column_index) ) && live_neighbor_count == 3 # rule 4

        end
      end
      if @current_board == @future_board # board is gridlocked. Game over!
        puts "\nGAME OVER!"
        exit!
      else
        @current_board = @future_board # update the board
        @ticks += 1
        sleep(1)
      end
    end
  end
end

print "How large of a grid do you want: "
grid_size = gets.to_i
game = Game.new grid_size
game.play

需要“撬动”
班级游戏
def初始化（大小）
@大小=大小
@滴答声=1
@当前_board=Array.new（size）{Array.new（size）{（rand（99）%5==0）？false:true}
@future_board=Array.new（size）{Array.new（size）}
#@future\u board=@current\u board
终止
def是否处于活动状态？（y，x）
如果@current_board[y]
@当前董事会[y][x]
终止
终止
def检查附近（y，x）
邻居={
顶部：[y-1，x]，
右上角：[y-1，x+1]，
右：[y，x+1]，
右下角：[y+1，x+1]，
底部：[y+1，x]，
左下角：[y+1，x-1]，
左：[y，x-1]，
左上角：[y-1，x-1]
}
相邻状态={
上图：错，
右上角：错，
右：错，
右下角：错误，
底部：错误，
左下：假，
左：错，
左上角：假
}
#捆绑，撬动
neights.each{k，v|neighter_state[k]=如果_还活着，则为真？（v[0]，v[1]）
活动\u邻居\u计数=0
邻居_状态。每个_值{| v | live_neighbor_count+=1如果v}
住在邻居家里
终止
def单元_寿命（y，x）
@未来董事会[y][x]=真实
终止
def单元_模具（y，x）
@未来董事会[y][x]=错误
终止
def显示板
#需要在这里展示板吗
系统（“清除”）
#@current_board.do
#| r | put r.map{| c | c'O'：'X'}.join（“”）
#| r | put r.map{c | c}.join（“”）
放置@current_board.map{| row | row.map{| cell | cell？'X'：''}.inspect}
#结束
放置“\n标记：{@ticks}”
终止
def播放
环道
显示板
@当前| u board.each do | r |#外部循环以遍历行
行索引=@current_board.index（r）.to_i
r、 每个do | c |#内部循环都可以遍历列
列索引=r.索引（c）.至
live_neighbor_count=检查邻居（行索引、列索引）#计算live neighbor的数量
如果单元（行索引、列索引）处于活动状态（行索引、列索引））&活动的邻居计数<2，则单元（行索引、列索引）将死亡
如果单元格（行索引、列索引）处于活动状态（行索引、列索引））&（活动邻居计数=2 |活动邻居计数=3），则单元格（行索引、列索引）处于活动状态
如果单元（行索引、列索引）处于活动状态（行索引、列索引））&活动邻居计数>3，则单元（行索引、列索引）死亡
单元格（行索引、列索引）如果存在！（行索引、列索引）和&live_邻居计数==3规则4
终止
终止
如果@current_board==@future_board#board被锁定。游戏结束！
放置“\n请将我放下！”
出口
其他的
@当前板=@未来板#更新板
@滴答声+=1
睡眠（1）
终止
终止
终止
终止
打印“您想要多大的网格：”
网格大小=get.to\u i
游戏=游戏。新网格大小
游戏

试试：-

 @current_board = @futureboard.dup

---

在康威的《生命游戏》中，如果你从一个随机排列的细胞开始，大多数细胞在第二个滴答声中死亡只是因为游戏规则，所以我没有证据表明存在缺陷

---

你做一架滑翔机或其他东西，确保它的性能符合预期，怎么样？如果它不起作用，那么请发布程序的输出，指出输出错误的第一帧，并发布您预期的输出。

没有ruby专家，但非常确定@current_board=@future_board使它们都指向相同的数据结构，您要做的是将futureboard复制到当前Board上这更像是一个代码审查。ruby社区已经决定使用2个空格而不是制表符。请尝试在您自己的代码中执行此操作。它使Ruby开发人员更容易阅读。不正确的缩进可能导致问题。因为ruby允许在方法名中使用

？

，所以不需要在谓词方法前面加上

is

。您的

处于活动状态？

方法可以调用

处于活动状态？

。谓词方法应始终仅返回

true

或

false

。当前，您的

alive？

方法可以返回

nil

。您可以将其缩短为

def alive？（y，x）@当前董事会[y][x]；结束

。谢谢你的建议。你能解释一下

@当前板[y][x]

件？也许我遗漏了什么，但是第一次检查@current_board[y]的原因是因为在检查邻居时，它导致了游戏崩溃。当邻居检查在最后一行设置y+1时，_是否活动？用一个不存在的行调用并崩溃。你的代码片段说明了这一点吗将对当前值求反。使用

将执行双重否定。这是将“truthy”值（如
nil
）转换为实际布尔值的公认方法。即使请求的索引中没有项目，这也会起作用。执行
arr[50][50]
将返回
nil
，假设该索引处没有任何内容（只要数组至少有两个深度）。所以
！！nil==false
。它只是保证您将始终返回
true
或
false
。如果您指的是在底部更新电路板的位置，尝试.dup和.clone会产生与没有这两个选项相同的结果。没用。谢谢，请继续。我不知道为什么我随机生成的细胞不能正常工作，而其他的细胞却正常工作。不确定这是否是问题所在。手动预设为众多设计中的一种，使《生活的游戏》正常运行。这