Hướng dẫn tic-tac-toe oop python - tic-tac-toe oop con trăn

Okay, giờ thì bắt đầu thoai.

1. Game TicTacToe chơi như thế nào?

Để chơi game, đầu tiên chúng ta cần một bảng 3x3 ô trống như thế này, tạm gọi là

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

irb(main):118:0> TicTacToe.new.display_board
   |   |   
-----------
   |   |   
-----------
   |   |   

Sẽ chỉ có 2 players, mỗi player tương ứng với 1

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

• Player 1 tương ứng với

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  6
• Player 2 tương ứng với

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  7 2 players sẽ chơi theo lượt ,

  class TicTacToe
    attr_reader :board
    WIN_COMBINATIONS = [
      [0,1,2],
      [3,4,5],
      [6,7,8],
      [0,3,6],
      [1,4,7],
      [2,5,8],
      [0,4,8],
      [2,4,6]
    ]
  
    def initialize(board = nil, options = {})
      @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
      @options = @options.merge(options)
      @board = board || Array.new(self.cells_count, @options[:chr_empty])
    end
  
    def cells_count
      @options[:rows]*@options[:cols]
    end
  
    def get_cell_from_row_col(row, col)
      # puts "row: #{row}, col: #{col}, cell: #{((row-1)*@options[:cols])+col-1}"
      @board[((row-1)*@options[:cols])+col-1]
    end
  
    def display_board
      @options[:rows].times.with_index(1) do |r, row_index|
        str_row = ''
        @options[:cols].times.with_index(1) do |c, col_index|
          str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
          str_row += @options[:chr_separ_v] if col_index < @options[:cols]
        end
        puts str_row
        puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
      end
    end
  
    def input_to_index(str_input)
      str_input.to_i-1
    end
  
    def move(index, player_token)
      @board[index] = player_token
    end
  
    def position_taken?(index)
      !@board[index].strip.empty?
    end
  
    def valid_move?(index)
      index.between?(0, cells_count-1) && !position_taken?(index)
    end
  
    def turn
      puts "Enter position (1-9):"
      index = input_to_index(gets.strip)
      if valid_move?(index)
        move(index, current_player)
        display_board
      else
        turn
      end
    end
  
    def turn_count
      counter = 0
      @board.each {|cell| counter += 1 unless cell.strip.empty?}
      counter
    end
  
    def current_player
      turn_count % 2 == 0 ? 'X' : 'O'
    end
  
    def won?
      ret = nil
      WIN_COMBINATIONS.each do |wc|
        if wc.all? { |index| position_taken?(index) && @board[index] == @board[wc[0]]}
          ret = wc
          break
        end
      end
      ret
    end
  
    def full?
      turn_count == cells_count
    end
  
    def draw?
      full? && !won?
    end
  
    def over?
      won? || full?
    end
  
    def winner
      won = won?
      won ? @board[won[0]] : nil
    end
  
    def play
      until over? do
        turn
      end
      if won?
        puts "Congratulations #{winner}!"
      else
        puts "Cat's Game!"
      end
    end
  end
  

  0 sẽ chơi lượt lẻ,

  class TicTacToe
    attr_reader :board
    WIN_COMBINATIONS = [
      [0,1,2],
      [3,4,5],
      [6,7,8],
      [0,3,6],
      [1,4,7],
      [2,5,8],
      [0,4,8],
      [2,4,6]
    ]
  
    def initialize(board = nil, options = {})
      @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
      @options = @options.merge(options)
      @board = board || Array.new(self.cells_count, @options[:chr_empty])
    end
  
    def cells_count
      @options[:rows]*@options[:cols]
    end
  
    def get_cell_from_row_col(row, col)
      # puts "row: #{row}, col: #{col}, cell: #{((row-1)*@options[:cols])+col-1}"
      @board[((row-1)*@options[:cols])+col-1]
    end
  
    def display_board
      @options[:rows].times.with_index(1) do |r, row_index|
        str_row = ''
        @options[:cols].times.with_index(1) do |c, col_index|
          str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
          str_row += @options[:chr_separ_v] if col_index < @options[:cols]
        end
        puts str_row
        puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
      end
    end
  
    def input_to_index(str_input)
      str_input.to_i-1
    end
  
    def move(index, player_token)
      @board[index] = player_token
    end
  
    def position_taken?(index)
      !@board[index].strip.empty?
    end
  
    def valid_move?(index)
      index.between?(0, cells_count-1) && !position_taken?(index)
    end
  
    def turn
      puts "Enter position (1-9):"
      index = input_to_index(gets.strip)
      if valid_move?(index)
        move(index, current_player)
        display_board
      else
        turn
      end
    end
  
    def turn_count
      counter = 0
      @board.each {|cell| counter += 1 unless cell.strip.empty?}
      counter
    end
  
    def current_player
      turn_count % 2 == 0 ? 'X' : 'O'
    end
  
    def won?
      ret = nil
      WIN_COMBINATIONS.each do |wc|
        if wc.all? { |index| position_taken?(index) && @board[index] == @board[wc[0]]}
          ret = wc
          break
        end
      end
      ret
    end
  
    def full?
      turn_count == cells_count
    end
  
    def draw?
      full? && !won?
    end
  
    def over?
      won? || full?
    end
  
    def winner
      won = won?
      won ? @board[won[0]] : nil
    end
  
    def play
      until over? do
        turn
      end
      if won?
        puts "Congratulations #{winner}!"
      else
        puts "Cat's Game!"
      end
    end
  end
  

  1 chơi lượt chẵn :
• Lượt 1 :

  class TicTacToe
    attr_reader :board
    WIN_COMBINATIONS = [
      [0,1,2],
      [3,4,5],
      [6,7,8],
      [0,3,6],
      [1,4,7],
      [2,5,8],
      [0,4,8],
      [2,4,6]
    ]
  
    def initialize(board = nil, options = {})
      @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
      @options = @options.merge(options)
      @board = board || Array.new(self.cells_count, @options[:chr_empty])
    end
  
    def cells_count
      @options[:rows]*@options[:cols]
    end
  
    def get_cell_from_row_col(row, col)
      # puts "row: #{row}, col: #{col}, cell: #{((row-1)*@options[:cols])+col-1}"
      @board[((row-1)*@options[:cols])+col-1]
    end
  
    def display_board
      @options[:rows].times.with_index(1) do |r, row_index|
        str_row = ''
        @options[:cols].times.with_index(1) do |c, col_index|
          str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
          str_row += @options[:chr_separ_v] if col_index < @options[:cols]
        end
        puts str_row
        puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
      end
    end
  
    def input_to_index(str_input)
      str_input.to_i-1
    end
  
    def move(index, player_token)
      @board[index] = player_token
    end
  
    def position_taken?(index)
      !@board[index].strip.empty?
    end
  
    def valid_move?(index)
      index.between?(0, cells_count-1) && !position_taken?(index)
    end
  
    def turn
      puts "Enter position (1-9):"
      index = input_to_index(gets.strip)
      if valid_move?(index)
        move(index, current_player)
        display_board
      else
        turn
      end
    end
  
    def turn_count
      counter = 0
      @board.each {|cell| counter += 1 unless cell.strip.empty?}
      counter
    end
  
    def current_player
      turn_count % 2 == 0 ? 'X' : 'O'
    end
  
    def won?
      ret = nil
      WIN_COMBINATIONS.each do |wc|
        if wc.all? { |index| position_taken?(index) && @board[index] == @board[wc[0]]}
          ret = wc
          break
        end
      end
      ret
    end
  
    def full?
      turn_count == cells_count
    end
  
    def draw?
      full? && !won?
    end
  
    def over?
      won? || full?
    end
  
    def winner
      won = won?
      won ? @board[won[0]] : nil
    end
  
    def play
      until over? do
        turn
      end
      if won?
        puts "Congratulations #{winner}!"
      else
        puts "Cat's Game!"
      end
    end
  end
  

  0 sẽ điền X vào 1 ô trong

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3
• Lượt 2 :

  class TicTacToe
    attr_reader :board
    WIN_COMBINATIONS = [
      [0,1,2],
      [3,4,5],
      [6,7,8],
      [0,3,6],
      [1,4,7],
      [2,5,8],
      [0,4,8],
      [2,4,6]
    ]
  
    def initialize(board = nil, options = {})
      @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
      @options = @options.merge(options)
      @board = board || Array.new(self.cells_count, @options[:chr_empty])
    end
  
    def cells_count
      @options[:rows]*@options[:cols]
    end
  
    def get_cell_from_row_col(row, col)
      # puts "row: #{row}, col: #{col}, cell: #{((row-1)*@options[:cols])+col-1}"
      @board[((row-1)*@options[:cols])+col-1]
    end
  
    def display_board
      @options[:rows].times.with_index(1) do |r, row_index|
        str_row = ''
        @options[:cols].times.with_index(1) do |c, col_index|
          str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
          str_row += @options[:chr_separ_v] if col_index < @options[:cols]
        end
        puts str_row
        puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
      end
    end
  
    def input_to_index(str_input)
      str_input.to_i-1
    end
  
    def move(index, player_token)
      @board[index] = player_token
    end
  
    def position_taken?(index)
      !@board[index].strip.empty?
    end
  
    def valid_move?(index)
      index.between?(0, cells_count-1) && !position_taken?(index)
    end
  
    def turn
      puts "Enter position (1-9):"
      index = input_to_index(gets.strip)
      if valid_move?(index)
        move(index, current_player)
        display_board
      else
        turn
      end
    end
  
    def turn_count
      counter = 0
      @board.each {|cell| counter += 1 unless cell.strip.empty?}
      counter
    end
  
    def current_player
      turn_count % 2 == 0 ? 'X' : 'O'
    end
  
    def won?
      ret = nil
      WIN_COMBINATIONS.each do |wc|
        if wc.all? { |index| position_taken?(index) && @board[index] == @board[wc[0]]}
          ret = wc
          break
        end
      end
      ret
    end
  
    def full?
      turn_count == cells_count
    end
  
    def draw?
      full? && !won?
    end
  
    def over?
      won? || full?
    end
  
    def winner
      won = won?
      won ? @board[won[0]] : nil
    end
  
    def play
      until over? do
        turn
      end
      if won?
        puts "Congratulations #{winner}!"
      else
        puts "Cat's Game!"
      end
    end
  end
  

  1 sẽ điền O vào 1 ô còn trống trong

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3còn trống trong

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3
• Lượt 3 :

  class TicTacToe
    attr_reader :board
    WIN_COMBINATIONS = [
      [0,1,2],
      [3,4,5],
      [6,7,8],
      [0,3,6],
      [1,4,7],
      [2,5,8],
      [0,4,8],
      [2,4,6]
    ]
  
    def initialize(board = nil, options = {})
      @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
      @options = @options.merge(options)
      @board = board || Array.new(self.cells_count, @options[:chr_empty])
    end
  
    def cells_count
      @options[:rows]*@options[:cols]
    end
  
    def get_cell_from_row_col(row, col)
      # puts "row: #{row}, col: #{col}, cell: #{((row-1)*@options[:cols])+col-1}"
      @board[((row-1)*@options[:cols])+col-1]
    end
  
    def display_board
      @options[:rows].times.with_index(1) do |r, row_index|
        str_row = ''
        @options[:cols].times.with_index(1) do |c, col_index|
          str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
          str_row += @options[:chr_separ_v] if col_index < @options[:cols]
        end
        puts str_row
        puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
      end
    end
  
    def input_to_index(str_input)
      str_input.to_i-1
    end
  
    def move(index, player_token)
      @board[index] = player_token
    end
  
    def position_taken?(index)
      !@board[index].strip.empty?
    end
  
    def valid_move?(index)
      index.between?(0, cells_count-1) && !position_taken?(index)
    end
  
    def turn
      puts "Enter position (1-9):"
      index = input_to_index(gets.strip)
      if valid_move?(index)
        move(index, current_player)
        display_board
      else
        turn
      end
    end
  
    def turn_count
      counter = 0
      @board.each {|cell| counter += 1 unless cell.strip.empty?}
      counter
    end
  
    def current_player
      turn_count % 2 == 0 ? 'X' : 'O'
    end
  
    def won?
      ret = nil
      WIN_COMBINATIONS.each do |wc|
        if wc.all? { |index| position_taken?(index) && @board[index] == @board[wc[0]]}
          ret = wc
          break
        end
      end
      ret
    end
  
    def full?
      turn_count == cells_count
    end
  
    def draw?
      full? && !won?
    end
  
    def over?
      won? || full?
    end
  
    def winner
      won = won?
      won ? @board[won[0]] : nil
    end
  
    def play
      until over? do
        turn
      end
      if won?
        puts "Congratulations #{winner}!"
      else
        puts "Cat's Game!"
      end
    end
  end
  

  0 sẽ điền X vào 1 ô còn trống trong

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3 .......còn trống trong

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3 .......
• Lượt 9 :

  class TicTacToe
    attr_reader :board
    WIN_COMBINATIONS = [
      [0,1,2],
      [3,4,5],
      [6,7,8],
      [0,3,6],
      [1,4,7],
      [2,5,8],
      [0,4,8],
      [2,4,6]
    ]
  
    def initialize(board = nil, options = {})
      @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
      @options = @options.merge(options)
      @board = board || Array.new(self.cells_count, @options[:chr_empty])
    end
  
    def cells_count
      @options[:rows]*@options[:cols]
    end
  
    def get_cell_from_row_col(row, col)
      # puts "row: #{row}, col: #{col}, cell: #{((row-1)*@options[:cols])+col-1}"
      @board[((row-1)*@options[:cols])+col-1]
    end
  
    def display_board
      @options[:rows].times.with_index(1) do |r, row_index|
        str_row = ''
        @options[:cols].times.with_index(1) do |c, col_index|
          str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
          str_row += @options[:chr_separ_v] if col_index < @options[:cols]
        end
        puts str_row
        puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
      end
    end
  
    def input_to_index(str_input)
      str_input.to_i-1
    end
  
    def move(index, player_token)
      @board[index] = player_token
    end
  
    def position_taken?(index)
      !@board[index].strip.empty?
    end
  
    def valid_move?(index)
      index.between?(0, cells_count-1) && !position_taken?(index)
    end
  
    def turn
      puts "Enter position (1-9):"
      index = input_to_index(gets.strip)
      if valid_move?(index)
        move(index, current_player)
        display_board
      else
        turn
      end
    end
  
    def turn_count
      counter = 0
      @board.each {|cell| counter += 1 unless cell.strip.empty?}
      counter
    end
  
    def current_player
      turn_count % 2 == 0 ? 'X' : 'O'
    end
  
    def won?
      ret = nil
      WIN_COMBINATIONS.each do |wc|
        if wc.all? { |index| position_taken?(index) && @board[index] == @board[wc[0]]}
          ret = wc
          break
        end
      end
      ret
    end
  
    def full?
      turn_count == cells_count
    end
  
    def draw?
      full? && !won?
    end
  
    def over?
      won? || full?
    end
  
    def winner
      won = won?
      won ? @board[won[0]] : nil
    end
  
    def play
      until over? do
        turn
      end
      if won?
        puts "Congratulations #{winner}!"
      else
        puts "Cat's Game!"
      end
    end
  end
  

  0 sẽ điền X vào 1 ô còn trống trong

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3còn trống trong

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3

Khi 9 ô trong

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

• Player 1 thắng.

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

• Player 2 thắng

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

• Hòa.

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

2. Giải thích sourecode của trang codingame.

Dưới đây là 116 dòng sourecode của class TicTacToe trên trang

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

class TicTacToe
  attr_reader :board
  WIN_COMBINATIONS = [
    [0,1,2],
    [3,4,5],
    [6,7,8],
    [0,3,6],
    [1,4,7],
    [2,5,8],
    [0,4,8],
    [2,4,6]
  ]

  def initialize(board = nil, options = {})
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @options = @options.merge(options)
    @board = board || Array.new(self.cells_count, @options[:chr_empty])
  end

  def cells_count
    @options[:rows]*@options[:cols]
  end

  def get_cell_from_row_col(row, col)
    # puts "row: #{row}, col: #{col}, cell: #{((row-1)*@options[:cols])+col-1}"
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

  def input_to_index(str_input)
    str_input.to_i-1
  end

  def move(index, player_token)
    @board[index] = player_token
  end

  def position_taken?(index)
    !@board[index].strip.empty?
  end

  def valid_move?(index)
    index.between?(0, cells_count-1) && !position_taken?(index)
  end

  def turn
    puts "Enter position (1-9):"
    index = input_to_index(gets.strip)
    if valid_move?(index)
      move(index, current_player)
      display_board
    else
      turn
    end
  end

  def turn_count
    counter = 0
    @board.each {|cell| counter += 1 unless cell.strip.empty?}
    counter
  end

  def current_player
    turn_count % 2 == 0 ? 'X' : 'O'
  end

  def won?
    ret = nil
    WIN_COMBINATIONS.each do |wc|
      if wc.all? { |index| position_taken?(index) && @board[index] == @board[wc[0]]}
        ret = wc
        break
      end
    end
    ret
  end

  def full?
    turn_count == cells_count
  end

  def draw?
    full? && !won?
  end

  def over?
    won? || full?
  end

  def winner
    won = won?
    won ? @board[won[0]] : nil
  end

  def play
    until over? do
      turn
    end
    if won?
      puts "Congratulations #{winner}!"
    else
      puts "Cat's Game!"
    end
  end
end

Bây giờ, mình sẽ đi vào giải thích 17

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

2.1 Tạo màn chơi mới.

Để tạo một màn chơi mới, ta cần khởi tạo một đối tượng của

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

Ta lưu màn chơi mới này bằng biến

  def initialize
    @options = {rows: 3, cols: 3, chr_empty: ' ', chr_separ_v: '|', chr_separ_h: '-', players: {'Player 1': 'X', 'Player 2': 'O'}}
    @board = Array.new(self.cells_count, @options[:chr_empty])
  end
  
  def cells_count
    @options[:rows]*@options[:cols]
  end

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

• irb(main):119:0> game = TicTacToe.new
  => #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>
  

  4 và

  irb(main):119:0> game = TicTacToe.new
  => #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>
  

  5 lưu số hàng và số cột của

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3 . (ở đây mặc định là 3x3) .

• irb(main):119:0> game = TicTacToe.new
  => #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>
  

  7,

  irb(main):119:0> game = TicTacToe.new
  => #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>
  

  8,

  irb(main):119:0> game = TicTacToe.new
  => #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>
  

  9 lưu các ký tự để vẽ lên board trong terminal như sau:

   |   |   
-----------
   |   |   
-----------
   |   |   

•    |   |   
  -----------
     |   |   
  -----------
     |   |   
  

  0 =

     |   |   
  -----------
     |   |   
  -----------
     |   |   
  

  1 là 1 hash lưu lại token của Player 1 và Player 2, phục vụ cho mục đích truy xuất xem cuối cùng ai là người thắng cuộc.

Về giá trị

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

 @board[0] | @board[1] | @board[2]  
----------------------------------
 @board[3] | @board[4] | @board[5]  
----------------------------------
 @board[6] | @board[7] | @board[8]  

Như vậy, quá trình chơi game tương ứng với quá trị gán giá trị cho các phần từ từ

   |   |   
-----------
   |   |   
-----------
   |   |   

2.2 Hiển thị board

Như vậy là ta đã tạo xong một màn chơi mới, giờ ta sẽ thử hiển thị board của màn chơi mới bằng

   |   |   
-----------
   |   |   
-----------
   |   |   

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

Hình ảnh board của màn chơi mới khởi tạo:

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

Mình sẽ giải thích về

   |   |   
-----------
   |   |   
-----------
   |   |   

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 @board[0] | @board[1] | @board[2]  
----------------------------------
 @board[3] | @board[4] | @board[5]  
----------------------------------
 @board[6] | @board[7] | @board[8]  

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 @board[0] | @board[1] | @board[2]  
----------------------------------
 @board[3] | @board[4] | @board[5]  
----------------------------------
 @board[6] | @board[7] | @board[8]  

Ví dụ,

• với row = 1, col = 1 ,

   @board[0] | @board[1] | @board[2]  
  ----------------------------------
   @board[3] | @board[4] | @board[5]  
  ----------------------------------
   @board[6] | @board[7] | @board[8]  
  

  0 trả về giá trị

   @board[0] | @board[1] | @board[2]  
  ----------------------------------
   @board[3] | @board[4] | @board[5]  
  ----------------------------------
   @board[6] | @board[7] | @board[8]  
  

  3
• với row = 2, col = 3 ,

   @board[0] | @board[1] | @board[2]  
  ----------------------------------
   @board[3] | @board[4] | @board[5]  
  ----------------------------------
   @board[6] | @board[7] | @board[8]  
  

  0 trả về giá trị

   @board[0] | @board[1] | @board[2]  
  ----------------------------------
   @board[3] | @board[4] | @board[5]  
  ----------------------------------
   @board[6] | @board[7] | @board[8]  
  

  5

Trở lại với

   |   |   
-----------
   |   |   
-----------
   |   |   

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

2.3 Chơi game thôi .

Sau khi khởi tạo màn chơi, chúng ta sẽ bắt đầu chơi bằng

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 @board[0] | @board[1] | @board[2]  
----------------------------------
 @board[3] | @board[4] | @board[5]  
----------------------------------
 @board[6] | @board[7] | @board[8]  

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

Để hiểu

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 @board[0] | @board[1] | @board[2]  
----------------------------------
 @board[3] | @board[4] | @board[5]  
----------------------------------
 @board[6] | @board[7] | @board[8]  

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

2.3.1 Method over?

Với

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

• TH1: Có 1 người chơi thắng trước khi

   X | O | X   
  -----------
   O | X | O   
  -----------
   O | X | O  
  => Cat's game
  

  3 bị đầy.

Trường hợp này sẽ được kiểm tra bằng

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

Người chơi

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

Điều tương tự xảy ra với người chơi

 X | O | X   
-----------
 O | X | O   
-----------
 O | X | O  
=> Cat's game

Xét các tổ hợp vị trí nói trên, ta suy ra được 8 trường hợp tương ứng với việc một trong 2 người chơi dành chiến thắng:8 trường hợp tương ứng với việc một trong 2 người chơi dành chiến thắng:

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

8 trường hợp dành chiến thắng này được lưu bởi hằng số

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

  def get_cell_from_row_col(row, col)
    @board[((row-1)*@options[:cols])+col-1]
  end

  def display_board
    @options[:rows].times.with_index(1) do |r, row_index|
      str_row = ''
      @options[:cols].times.with_index(1) do |c, col_index|
        str_row += @options[:chr_empty]+get_cell_from_row_col(row_index, col_index)+@options[:chr_empty]
        str_row += @options[:chr_separ_v] if col_index < @options[:cols]
      end
      puts str_row
      puts @options[:chr_separ_h]*((@options[:cols]*3)+@options[:cols]-1) if row_index < @options[:rows]
    end
  end

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

• TH2: Board bị đầy . Tức là

  irb(main):119:0> game = TicTacToe.new
  => #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>
  

  1 đã đủ 9 phần tử có giá trị 'X' hoặc 'O' .

Trường hợp này được kiểm tra bằng

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

2.3.2 Method turn

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

Như vậy là mình đã giải thích xong cách mà các method trong

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

3. Thử tạo ra game cờ caro nxn (n>3)

Để tạo ra game cờ caro nxn (n>3) khá đơn giản, chúng ta chỉ cần sửa lại

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

Mình sẽ thử với trường hợp 4x4 . Đầu tiên, với biến

irb(main):119:0> game = TicTacToe.new
=> #3, :cols=>3, :chr_empty=>" ", :chr_separ_v=>"|", :chr_separ_h=>"-", :players=>{:"Player 1"=>"X", :"Player 2"=>"O"}}, @board=[" ", " ", " ", " ", " ", " ", " ", " ", " "]>

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

Tiếp theo, chúng ta sửa

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

Toàn bộ phần

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

Mình sẽ thử chơi với

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

Như vậy mấu chốt để tạo ra game cờ caro

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X |   | X   
-----------
   | X |    
-----------
 O | O | O  
=> Congratulations O!

Với n < 8, các bạn hoàn toàn có thể dùng

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

 X | X | X   
-----------
 O |   |    
-----------
   | O | O   
 => Congratulations X!

4. Tạm biệt

Chốt lại, ở các phần sau của bài viết, mình sẽ giải quyết các vấn đề sau:

• Thuật toán tạo

   X | X | X   
  -----------
   O |   |    
  -----------
     | O | O   
   => Congratulations X!
  

  05 với tham số n cho trước.
• Mông má thêm 1 chút HTML, CSS, JS + Rails để tạo một webgame TicTacToe

Còn bây giờ thì tạm biệt.

References:

https://www.codingame.com/playgrounds/46635/tic-tac-toe-game-implementation