v1.5 Usage of Arrays, removed unnecessary recursion

import turtle
import math

class TicTacToeGame():
  def __init__(self):
    self.board_drawer = turtle.Turtle()
    self.screen_width = turtle.Screen().window_width()
    self.screen_height = turtle.Screen().window_height()
    self.setScale()
    self.square_size = self.box_size / 3
    self.total_squares = 9
    self.width = 1
    self.height = 1
    self.board = {}
    self.board_xcor = turtle.Screen().window_width() / -5.5
    self.board_ycor = turtle.Screen().window_height() / 2.5
    self.drawGrid()
    self.registerShapes()
    self.scoreturtle = turtle.Turtle()
    self.scoreturtle.ht()

  def setScale(self):
    if self.screen_width < self.screen_height:
      self.box_size = self.screen_width / 1.5
    else:
      self.box_size = self.screen_height / 1.5

  def gameover(self):
    turtle.Screen().resetscreen()
    self.scoreturtle.speed(0)
    self.scoreturtle.ht()
    self.scoreturtle.penup()
    self.scoreturtle.setposition(0, 0)
    self.scoreturtle.write("Game Over!", False, align="center", font=("Arial", 32, "normal"))
    self.obstacles = {}
    self.food = {}
    self.ghosts = []
    self.gameOver = True

  def registerShapes(self):
    screen = turtle.Screen()
    q = 5 * self.square_size / 12
    screen.register_shape("X", (
        (0, 0),
        (-q, -q),
        (q, q),
        (0, 0),
        (-q, q),
        (q, -q)))
    screen.register_shape("O", (
        (q, 0),
        (0.9659 * q, 0.2588 * q),
        (0.8660 * q, 0.5 * q),
        (0.7071 * q, 0.7071 * q),
        (0.5 * q, 0.8660 * q),
        (0.2588 * q, 0.9659 * q),
        (0, q),
        (-0.2588 * q, 0.9659 * q),
        (-0.5 * q, 0.8660 * q),
        (-0.7071 * q, 0.7071 * q),
        (-0.8660 * q, 0.5 * q),
        (-0.9659 * q, 0.2588 * q),
        (-q, 0),
        (-0.9659 * q, -0.2588 * q),
        (-0.8660 * q, -0.5 * q),
        (-0.7071 * q, -0.7071 * q),
        (-0.5 * q, -0.8660 * q),
        (-0.2588 * q, -0.9659 * q),
        (0, -q),
        (0.2588 * q, -0.9659 * q),
        (0.5 * q, -0.8660 * q),
        (0.7071 * q, -0.7071 * q),
        (0.8660 * q, -0.5 * q),
        (0.9659 * q, -0.2588 * q)))

  def drawGrid(self):
    self.board_drawer.penup()
    self.board_drawer.ht()
    self.board_drawer.speed(0)
    self.board_drawer.setpos(self.board_xcor,
                             self.board_ycor)
    self.board_drawer.pendown()
    self.board_drawer.forward(self.box_size * self.width)
    self.board_drawer.right(90)
    self.board_drawer.forward(self.box_size * self.height)
    self.board_drawer.right(90)
    self.board_drawer.forward(self.box_size * self.width)
    self.board_drawer.right(90)
    self.board_drawer.forward(self.box_size * self.height)
    self.board_drawer.penup()
    self.board_drawer.right(90)
    self.board_drawer.forward(self.square_size * self.width)
    self.board_drawer.pendown()
    self.board_drawer.right(90)
    self.board_drawer.forward(self.box_size * self.height)
    self.board_drawer.penup()
    self.board_drawer.left(90)
    self.board_drawer.forward(self.square_size * self.width)
    self.board_drawer.pendown()
    self.board_drawer.left(90)
    self.board_drawer.forward(self.box_size * self.height)
    self.board_drawer.penup()
    self.board_drawer.right(90)
    self.board_drawer.forward(self.square_size * self.width)
    self.board_drawer.right(90)
    self.board_drawer.forward(self.square_size * self.height)
    self.board_drawer.pendown()
    self.board_drawer.right(90)
    self.board_drawer.forward(self.box_size * self.width)
    self.board_drawer.penup()
    self.board_drawer.left(90)
    self.board_drawer.forward(self.square_size * self.height)
    self.board_drawer.pendown()
    self.board_drawer.left(90)
    self.board_drawer.forward(self.box_size * self.width)

  def moveObject(self, obj, width, height):
    obj.setpos(((turtle.Screen().window_width() / -5.5) + self.square_size / 2 + self.square_size * (width - 1)),
               (((turtle.Screen().window_height() / 2.5) - self.square_size / 2 - self.square_size * (height - 1))))
    return

  def createX(self, width, height):
    x = turtle.Turtle()
    x.speed(0)
    x.shape("X")
    x.penup()
    self.moveObject(x, width, height)
    store_val = (width * 10) + height
    self.moveObject(x, width, height)
    self.board[store_val] = ["x"]
    return

  def createO(self, width, height):
    o = turtle.Turtle()
    o.speed(0)
    o.shape("O")
    o.fillcolor("white")
    o.penup()
    store_val = (width * 10) + height
    self.moveObject(o, width, height)
    self.board[store_val] = ["o"]
    return

  def getSquare(self, width, height):
    store_val = (width * 10) + height
    return self.board[store_val]

  def checkFilled(self, width, height):
    store_val = (width * 10) + height
    if store_val in self.board:
      return True
    else:
      return False

  def doNothing(self):
    self.trasht.ht()

game = TicTacToeGame()
screen = turtle.Screen()
mainTurn = True
xcor = game.board_xcor
ycor = game.board_ycor
sq_size = game.square_size

boardstate = []
boardstate.append([0, 0, 0])
boardstate.append([0, 0, 0])
boardstate.append([0, 0, 0])
#  0 -> empty
#  1 -> filled with X
#  2 -> filled with O


def checkStatus():
  #checks if rows are matching
  for i in range(3):
    if not boardstate[i][0] == 0:
      if boardstate[i][0] == boardstate[i][1] and boardstate[i][0] == boardstate[i][2]:
        game.gameover()
  #checks if columns are matching
  for j in range(3):
    if not boardstate[0][j] == 0:
      if boardstate[0][j] == boardstate[1][j] and boardstate[0][j] == boardstate[2][j]:
        game.gameover()
  #checks if diagonals are matching
  if not boardstate[0][0] == 0:
    if boardstate[0][0] == boardstate[1][1] and boardstate[0][0] == boardstate[2][2]:
      game.gameover()
  if not boardstate[2][0] == 0:
    if boardstate[2][0] == boardstate[1][1] and boardstate[2][0] == boardstate[0][2]:
      game.gameover()
  #if entire board is filled, tied
  for k in range(3):
    for l in range(3):
      if not boardstate[k][l] == 0:
        checker += 1
  if checker == 9:
    game.gameover()

def makeMove(width, height):
  global mainTurn
  global boardstate
  #checks if moving position is already full
  if not boardstate[height-1][width-1] == 0:
    print "Not a valid move!"
  else:
    #checks if its X's turn
    if mainTurn:
      game.createX(width, height)
      mainTurn = False
      boardstate[height-1][width-1] = 1
      checkStatus()
    else:
      #else it's O's turn
      game.createO(width, height)
      mainTurn = True
      boardstate[height-1][width-1] = 2
      checkStatus()

def checkMove(x, y):
  #makes sure the click is a valid move
  width = (int) (math.floor((x - xcor)/sq_size) + 1)
  height = (int) (math.floor((ycor - y)/sq_size) + 1)
  if 1 <= width and width <= 3:
    if 1 <= height and height <= 3:
      makeMove(width, height)

screen.onclick(checkMove)