Wrote TicTacToe in ruby and the computer is not playing nice - ruby

Question

Basically the computer_make_move method is simple. I just want it to pick an open position and take it. It's meant to be dumb. It's not meant to play skillfully (yet).
Problem is that for some off reason. Every time I make a move, the computer makes a random number of moves.. Sometimes 1, other times 3 or 6. Just strange behavior. I don't understand why.
Note any reference to a method not seen here is in the gameart.rb file and it all art eg. you_win is just art, no logic at all.
Here is all the code:
class TicTacToe
require 'colorize'
require_relative 'lib/gameart.rb'
attr_reader :home_screen_ninja_art
WINS = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 5, 9], [3, 5, 7], [1, 4, 7], [2, 5, 8], [3, 6, 9]]
##scoreboard = {player: 0, computer: 0, tie: 0}
def initialize name, mark
#name, #gameover, #game_memory, #winner = name, false, ['_','_','_','_','_','_','_','_','_'], ''
mark == 'X' ? (#player, #computer = 'X', 'O') : (#player, #computer = 'O', 'X')
end
def menu i
return render_board if i == 99
return about if i == 100
return how_to_play if i == 200
return scoreboard if i == 300
return goodbye if i == 400
end
def action move
return menu(move) if move > 10
current_caller = caller[0] =~ /computer_make_move/ ? #computer : #player
i = move-1
if #game_memory[i] == '_'
render_board(i, current_caller)
else
try_again_art
end
end
def computer_make_move
action(current_board_positions[2].sample+1) # just pick any random open space for now
end
def render_board input=nil, caller=nil
if #gameover == false && !input.nil?
#game_memory[input] = caller
verify_game_state
end
if #gameover == true
game_over_art
case
when #winner == 'TIE' then you_tied
when #winner == #player then you_win
when #winner != #player then you_lose
end
end
board = #game_memory.map {|ps| ps == 'X' ? ps.colorize(:blue) : ps.colorize(:green) }.map {|ps| ps.gsub(/_/, " ")}
show_board board
end
def current_board_positions
x_positions, o_positions = [], []
#game_memory.select.with_index do |v,i|
x_positions << i+1 if v == 'X'
o_positions << i+1 if v == 'O'
end
open_positions = (1..9).to_a - (x_positions + o_positions)
[x_positions, o_positions, open_positions]
end
def verify_game_state
x, o, open = current_board_positions
find_winner = ->side { WINS.map {|win| side.combination(3).to_a.map {|set| set == win }.include? true } }
case
when (find_winner.(x).include? true)
#gameover=true
#winner='X'
when (find_winner.(o).include? true)
#gameover=true
#winner='O'
when !#game_memory.include?('_')
#gameover=true
#winner='TIE'
else
computer_make_move
end
end
end
This is how I initialize the game:
# Start a game
def start_new_game name, mark
#f = TicTacToe.new(name, mark)
puts #f.action 99
loop do
if #f.instance_variable_get :#gameover
puts 'Ready to play again?'.colorize(:white).on_red
print ' y|yes '.colorize(:green)
print ' n|no '.colorize(:red)
valid = false
until valid
startover = gets.chomp
valid = true if startover =~ /y|n|yes|no/i
end
if startover =~ /y|yes/i
start_new_game name, mark
else
#f.goodbye
end
else
print "* "
puts "Make your move #{name}:".colorize(:white).on_red
end
move = gets.chomp
puts #f.action move.to_i
end
end
valid = false
until valid
TicTacToe.home_screen_ninja_art
puts 'What is your name?'.colorize(:white).on_red
name = gets.chomp
valid = true if name.length > 1
end
valid = false
until valid
TicTacToe.home_screen_ninja_art
puts 'Pick your mark?'.colorize(:white).on_red
print ' X '.colorize(:blue)
print ' O '.colorize(:green)
puts ''
mark = gets.chomp.upcase
if mark =~ /X|O/i
valid = true
end
end
start_new_game name, mark

Answer 1

In method verify_game_state that calls after each render_board there is no case when person make move. It has only someone winners or tie, OR computer_make_move, so no noly computer should make a move.
So every time when it's not the end of the game, computer make a move, until it is, as i can see.