SHARE
TWEET

Untitled

a guest Jan 22nd, 2020 80 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import random
  2.  
  3. import pygame
  4.  
  5. SCREEN_WIDTH, SCEEN_HEIGHT = 500, 600
  6. screen = pygame.display.set_mode((SCREEN_WIDTH, SCEEN_HEIGHT))
  7. pygame.display.set_caption("Tic Tac Toe")
  8. clock = pygame.time.Clock()
  9. pygame.init()
  10. pygame.font.init()
  11. my_font = pygame.font.SysFont('impact', 35)
  12. win = my_font.render("YOU WIN ", True, (150, 150, 150))
  13. lose = my_font.render("YOU LOSE", True, (150, 150, 150))
  14. introimage = pygame.image.load('veryintroimage.png')
  15. tietext = my_font.render("Tie Game! Press space to return", True, (150, 150, 150)) #Tie message
  16. wintext = my_font.render("You win! Press space to return", True, (150, 150, 150)) #win message
  17. losetext = my_font.render("You Lose!! Press space to return", True, (150, 150, 150)) #Lose text
  18. XWin = my_font.render("X Has won the game!", True, (150, 150, 150)) #Lose text
  19. OWin = my_font.render("O Has won the game!", True, (150, 150, 150)) #Lose text
  20. choose = pygame.image.load('choose.png') #IMAGE
  21. friend = pygame.image.load('friend.png')
  22. hard = pygame.image.load('hard.png')
  23. normal = pygame.image.load('normal.png')
  24. X = pygame.image.load('x.png')
  25. O = pygame.image.load('o.png')
  26. grid = pygame.image.load('grid.png')
  27. play = pygame.image.load('play.png')#IMAGE
  28.  
  29. class Click: #Changes screens/ detects clicks
  30.     def __init__(self, Type):
  31.         self.type = Type
  32.  
  33.     def image(self, surface, name, x, y):
  34.         surface.blit(name, (x, y))
  35.  
  36.     def detectclick(self, surface, name, x, y):  # homescreen with norma
  37.         global gamestate
  38.         self.mousepos = pygame.mouse.get_pos()
  39.         self.click = pygame.mouse.get_pressed()
  40.         self.b = surface.blit(name, (x, y))
  41.         for i in range(0, 6):
  42.             if self.type == i:
  43.                 if self.b.collidepoint(self.mousepos) and self.click[0] == 1:
  44.                     gamestate = i + 1
  45.  
  46.  
  47. Turns = False
  48. class GridScreenNormal: #CREATES GRID
  49.     def __init__(self, x, y):
  50.         self.x = x
  51.         self.y = y
  52.         self.contains = ""
  53.     def draw(self, surface):
  54.         global Turns
  55.         global X
  56.         global O
  57.         pygame.draw.rect(surface, (0, 0, 0), (self.x, self.y, 133, 133), 1)
  58.         if self.contains == "O":
  59.             surface.blit(O, (self.x, self.y))
  60.         elif self.contains == "X":
  61.             surface.blit(X, (self.x, self.y))
  62.  
  63.     def check_clicked(self, mousepos):
  64.         rect = pygame.Rect(self.x, self.y, 133, 133)
  65.         if rect.collidepoint(mousepos[0], mousepos[1]):
  66.             return True
  67.         return False
  68.  
  69.     def set_contains(self, new_value):
  70.         self.contains = new_value
  71.  
  72.     def ai(self):
  73.         global Turns
  74. grid_array = [] #CREATES EACH GRID SQUARE USING THE CLASS AS A TEMPLATE
  75. for i in [0, 1, 2]:
  76.     grid_line = []
  77.     for j in [0, 1, 2]:
  78.         x = [50, 183, 316][i]
  79.         y = [166, 299, 432][j]
  80.         grid_square = GridScreenNormal(x, y)
  81.         grid_line.append(grid_square)
  82.     grid_array.append(grid_line)
  83. tie = [] #TIE LIST
  84. a = grid_array
  85. Button1 = Click(1) #BUTTON FOR CHANGING GAMESTATES
  86. Button2 = Click(2)
  87. Button3 = Click(3)
  88. Button4 = Click(4)
  89. Button5 = Click(5)
  90. gameend = True #CHECKS IF GAME ENDED
  91. gamestate = 1
  92. notie = True #If game was tie
  93. playerturn = 1
  94. ready = 0
  95. ready1 = 0
  96. running = True
  97. while running:
  98.     for event in pygame.event.get():
  99.         if event.type == pygame.QUIT:
  100.             running = False
  101.         if event.type == pygame.MOUSEBUTTONDOWN:
  102.             if gamestate == 3: #detects clicks
  103.                 mousepos = pygame.mouse.get_pos()
  104.                 if gameend == True:
  105.                     for i in range(0, 3, 1):
  106.                         for j in range(0, 3, 1):
  107.                             if grid_array[i][j].check_clicked(mousepos) == True:
  108.                                 if grid_array[i][j].contains == (""):
  109.                                     grid_array[i][j].set_contains("X")
  110.                                     tie.append(1)
  111.                                     Turns = True
  112.             if gamestate == 4 :
  113.                 mousepos = pygame.mouse.get_pos()
  114.                 if gameend == True :
  115.                     for i in range(0, 3, 1) :
  116.                         for j in range(0, 3, 1) :
  117.                             if grid_array[i][j].check_clicked(mousepos) == True :
  118.                                 if grid_array[i][j].contains == ("") :
  119.                                     grid_array[i][j].set_contains("X")
  120.                                     tie.append(1)
  121.                                     Turns = True
  122.             if gamestate == 5 :
  123.                 mousepos = pygame.mouse.get_pos()
  124.                 if gameend == True :
  125.                     if playerturn == 1:
  126.                         for i in range(0, 3, 1) :
  127.                             for j in range(0, 3, 1) :
  128.                                 if grid_array[i][j].check_clicked(mousepos) == True :
  129.                                     if grid_array[i][j].contains == ("") :
  130.                                         grid_array[i][j].set_contains("X")
  131.                                         playerturn = 2
  132.                                         tie.append(1)
  133.                     if playerturn == 2:
  134.                         for i in range(0, 3, 1) :
  135.                             for j in range(0, 3, 1) :
  136.                                 if grid_array[i][j].check_clicked(mousepos) == True :
  137.                                     if grid_array[i][j].contains == ("") :
  138.                                         playerturn = 1
  139.                                         grid_array[i][j].set_contains("O")
  140.                                         tie.append(1)
  141.     k = pygame.key.get_pressed()
  142.     if gamestate == 1: #Intro Screen/ play
  143.         Button1.image(screen, introimage, 0, 0)
  144.         Button1.image(screen, play, 170, 300)
  145.         Button1.detectclick(screen, play, 170, 300)
  146.         pygame.display.update()
  147.         clock.tick(60)
  148.     if gamestate == 2: #Menu screen with normal hard and friend
  149.         Button1.image(screen, choose, 0, 0)
  150.         Button2.image(screen, normal, 170, 250)
  151.         Button2.detectclick(screen, normal, 170, 250)
  152.         Button3.image(screen, hard, 170, 350)
  153.         Button3.detectclick(screen, hard, 170, 350)
  154.         Button4.image(screen, friend, 170, 450)
  155.         Button4.detectclick(screen, friend, 170, 450)
  156.         pygame.display.update()
  157.         clock.tick(60)
  158.     if gamestate == 3:  # NORMAL TIC TAC TOE GAME (NORMAL AI)
  159.         screen.fill((10, 10, 10))
  160.         pygame.draw.rect(screen, (0, 204, 204), (50, 166, 400, 400))
  161.         if Turns == True:  # AI plays randomly
  162.             i = random.randint(0, 2)
  163.             j = random.randint(0, 2)
  164.             if grid_array[i][j].contains == (""):
  165.                 grid_array[i][j].set_contains("O")
  166.                 tie.append(1)
  167.                 Turns = False
  168.  
  169.         x_wins = False
  170.         o_wins = False
  171.         for i in [0, 1, 2]: #CHECK IF O OR X WINS
  172.             row_is_x = True
  173.             row_is_o = True
  174.             for j in [0, 1, 2]:
  175.                 if grid_array[i][j].contains != "X":
  176.                     row_is_x = False
  177.                 if grid_array[i][j].contains != "O":
  178.                     row_is_o = False
  179.             if row_is_x:
  180.                 x_wins = True
  181.             if row_is_o:
  182.                 o_wins = True
  183.         for j in [2, 1, 0]:
  184.             row_is_y = True
  185.             row_is_oy = True
  186.             for i in [0, 1, 2]:
  187.                 if grid_array[i][j].contains != "X":
  188.                     row_is_y = False
  189.                 if grid_array[i][j].contains != "O":
  190.                     row_is_oy = False
  191.             if row_is_y:
  192.                 x_wins = True
  193.             if row_is_oy:
  194.                 o_wins = True
  195.         row_is_d = True
  196.         row_is_do = True
  197.         for i in range(0, 3):
  198.             if grid_array[i][i].contains != "X":
  199.                 row_is_d = False
  200.             if grid_array[i][i].contains != "O":
  201.                 row_is_do = False
  202.         if row_is_d:
  203.             x_wins = True
  204.         if row_is_do:
  205.             o_wins = True
  206.         row_is_dd = True
  207.         row_is_ddo = True
  208.         for i in range(0, 3):
  209.             if grid_array[i][2 - i].contains != "X":
  210.                 row_is_dd = False
  211.                 print("bruh")
  212.             if grid_array[i][2 - i].contains != "O":
  213.                 row_is_ddo = False
  214.                 print("bruh")
  215.         if row_is_dd:
  216.             x_wins = True
  217.         if row_is_ddo:
  218.             o_wins = True
  219.         if x_wins: #IF X WON CHANGE GAMESTATE AND RESET GAME
  220.             o_wins = False
  221.             Turns = False
  222.             gameend = False
  223.             screen.blit(wintext, (10, 0))
  224.             notie = False
  225.             gameend = False
  226.             if k[pygame.K_SPACE]:
  227.                 gamestate = 2
  228.                 gameend = True
  229.                 notie = True
  230.                 for i in range(0, 3):
  231.                     for j in range(0, 3):
  232.                         grid_array[i][j].contains = ""
  233.                         tie = []
  234.                         x_wins = False
  235.         if o_wins:#IF O WON CHANGE GAMESTATE AND RESET GAME
  236.             x_wins = False
  237.             Turns = False
  238.             screen.blit(losetext, (10, 0))
  239.             notie = False
  240.             gameend = False
  241.             if k[pygame.K_SPACE]:
  242.                 gamestate = 2
  243.                 gameend = True
  244.                 tie = []
  245.                 notie = True
  246.                 o_wins = False
  247.                 for i in range(0, 3):
  248.                     for j in range(0, 3):
  249.                         grid_array[i][j].contains = ""
  250.         if notie == True: #IF GAME TIED THAN RESET GAME AND TELL PLAYERS MESSAGE THAT NO  PLAYER WON
  251.             if len(tie) >= 9:
  252.                 screen.blit(tietext, (10, 0))
  253.                 if k[pygame.K_SPACE]:
  254.                     gameend = True
  255.                     notie = True
  256.                     gamestate = 2
  257.                     tie = []
  258.                     o_wins = False
  259.                     for i in range(0, 3):
  260.                         for j in range(0, 3):
  261.                             grid_array[i][j].contains = ""
  262.  
  263.         screen.blit(grid, (50, 166))
  264.         for grid_line in grid_array: #Draws
  265.             for grid_square in grid_line:
  266.                 grid_square.draw(screen)
  267.         pygame.display.update()
  268.         clock.tick(60)
  269.     if gamestate == 4: #HARD AI SCREEN
  270.         screen.fill((10, 10, 10))
  271.         pygame.draw.rect(screen, (204, 0, 0), (50, 166, 400, 400))
  272.         '''
  273.        Sadly I couldnt figure it out and had to do something different
  274.        if Turns == True:
  275.            test = random.randint(0, 2)
  276.            play_i = 0
  277.            play_j = 0
  278.            for i in [0, 1, 2]:
  279.                x_count = 0
  280.                for j in [0, 1, 2]:
  281.                    if grid_array[i][j].contains != "X":
  282.                        x_count = x_count + 1
  283.                if x_count == 2:
  284.                    play_i = i
  285.                    for j in [0, 1, 2]:
  286.                        if grid_array[i][j].contains == "":
  287.                            play_j = j
  288.        '''
  289.         if Turns == True :  # AI plays randomly twice
  290.             lp = random.randint(0, 2)
  291.             lo = random.randint(0, 2)
  292.             lpo = random.randint(0, 2)
  293.             loo = random.randint(0, 2)
  294.             print(tie)
  295.             if grid_array[i][j].contains == ("") and ready == 0:
  296.                 grid_array[lp][lo].set_contains("O")
  297.                 ready = ready + 1
  298.                 tie.append(1)
  299.             if grid_array[i][j].contains == ("") and ready1 == 0:
  300.                 grid_array[lpo][loo].set_contains("O")
  301.                 tie.append(1)
  302.  
  303.                 ready1 = ready1 + 1
  304.             if ready + ready1 == 2:
  305.                 ready = 0
  306.                 ready1 = 0
  307.                 Turns = False
  308.  
  309.         x_wins = False
  310.         o_wins = False
  311.         for i in [0, 1, 2] : #CHECK IF X OR O WON
  312.             row_is_x = True
  313.             row_is_o = True
  314.             for j in [0, 1, 2] :
  315.                 if grid_array[i][j].contains != "X" :
  316.                     row_is_x = False
  317.                 if grid_array[i][j].contains != "O" :
  318.                     row_is_o = False
  319.             if row_is_x :
  320.                 x_wins = True
  321.             if row_is_o :
  322.                 o_wins = True
  323.         for j in [2, 1, 0] :
  324.             row_is_y = True
  325.             row_is_oy = True
  326.             for i in [0, 1, 2] :
  327.                 if grid_array[i][j].contains != "X" :
  328.                     row_is_y = False
  329.                 if grid_array[i][j].contains != "O" :
  330.                     row_is_oy = False
  331.             if row_is_y :
  332.                 x_wins = True
  333.             if row_is_oy :
  334.                 o_wins = True
  335.         row_is_d = True
  336.         row_is_do = True
  337.         for i in range(0, 3) :
  338.             if grid_array[i][i].contains != "X" :
  339.                 row_is_d = False
  340.             if grid_array[i][i].contains != "O" :
  341.                 row_is_do = False
  342.         if row_is_d :
  343.             x_wins = True
  344.         if row_is_do :
  345.             o_wins = True
  346.         row_is_dd = True
  347.         row_is_ddo = True
  348.         for i in range(0, 3) :
  349.             if grid_array[i][2 - i].contains != "X" :
  350.                 row_is_dd = False
  351.             if grid_array[i][2 - i].contains != "O" :
  352.                 row_is_ddo = False
  353.         if row_is_dd :
  354.             x_wins = True
  355.         if row_is_ddo :
  356.             o_wins = True
  357.         if x_wins : #If X won then reset game and tell player X won
  358.             o_wins = False
  359.             Turns = False
  360.             gameend = False
  361.             screen.blit(wintext, (10, 0))
  362.             notie = False
  363.             gameend = False
  364.             if k[pygame.K_SPACE] :
  365.                 gamestate = 2
  366.                 gameend = True
  367.                 notie = True
  368.                 for i in range(0, 3) :
  369.                     for j in range(0, 3) :
  370.                         grid_array[i][j].contains = ""
  371.                         tie = []
  372.                         x_wins = False
  373.         if o_wins :#If O won then reset game and tell player X won
  374.             x_wins = False
  375.             Turns = False
  376.             screen.blit(losetext, (10, 0))
  377.             notie = False
  378.             gameend = False
  379.             if k[pygame.K_SPACE] :
  380.                 gamestate = 2
  381.                 gameend = True
  382.                 tie = []
  383.                 notie = True
  384.                 o_wins = False
  385.                 for i in range(0, 3) :
  386.                     for j in range(0, 3) :
  387.                         grid_array[i][j].contains = ""
  388.         if notie == True : #IF GAME TIE THAN RESET GAME AND TELL PLAYERS NO WINNERS
  389.             if len(tie) >= 9 :
  390.                 screen.blit(tietext, (10, 0))
  391.                 if k[pygame.K_SPACE] :
  392.                     gameend = True
  393.                     notie = True
  394.                     gamestate = 2
  395.                     tie = []
  396.                     o_wins = False
  397.                     for i in range(0, 3) :
  398.                         for j in range(0, 3) :
  399.                             grid_array[i][j].contains = ""
  400.  
  401.         screen.blit(grid, (50, 166))
  402.         for grid_line in grid_array :
  403.             for grid_square in grid_line :
  404.                 grid_square.draw(screen)
  405.         pygame.display.update()
  406.         clock.tick(60)
  407.     if gamestate == 5: #NORMAL GRID SCREEN/ PLAYER VS PLAYER
  408.         screen.fill((10, 10, 10))
  409.         pygame.draw.rect(screen, (0, 204, 0), (50, 166, 400, 400))
  410.         x_wins = False
  411.         o_wins = False
  412.         for i in [0, 1, 2] : #CHECKS WHO WON
  413.             row_is_x = True
  414.             row_is_o = True
  415.             for j in [0, 1, 2] :
  416.                 if grid_array[i][j].contains != "X" :
  417.                     row_is_x = False
  418.                 if grid_array[i][j].contains != "O" :
  419.                     row_is_o = False
  420.             if row_is_x :
  421.                 x_wins = True
  422.             if row_is_o :
  423.                 o_wins = True
  424.         for j in [2, 1, 0] :
  425.             row_is_y = True
  426.             row_is_oy = True
  427.             for i in [0, 1, 2] :
  428.                 if grid_array[i][j].contains != "X" :
  429.                     row_is_y = False
  430.                 if grid_array[i][j].contains != "O" :
  431.                     row_is_oy = False
  432.             if row_is_y :
  433.                 x_wins = True
  434.             if row_is_oy :
  435.                 o_wins = True
  436.         row_is_d = True
  437.         row_is_do = True
  438.         for i in range(0, 3) :
  439.             if grid_array[i][i].contains != "X" :
  440.                 row_is_d = False
  441.             if grid_array[i][i].contains != "O" :
  442.                 row_is_do = False
  443.         if row_is_d :
  444.             x_wins = True
  445.         if row_is_do :
  446.             o_wins = True
  447.         row_is_dd = True
  448.         row_is_ddo = True
  449.         for i in range(0, 3) :
  450.             if grid_array[i][2 - i].contains != "X" :
  451.                 row_is_dd = False
  452.             if grid_array[i][2 - i].contains != "O" :
  453.                 row_is_ddo = False
  454.         if row_is_dd :
  455.             x_wins = True
  456.         if row_is_ddo :
  457.             o_wins = True
  458.         if x_wins : #IF X WON THEN RESET
  459.             o_wins = False
  460.             Turns = False
  461.             gameend = False
  462.             screen.blit(XWin, (10, 0))
  463.             notie = False
  464.             gameend = False
  465.             if k[pygame.K_SPACE] :
  466.                 gamestate = 2
  467.                 gameend = True
  468.                 notie = True
  469.                 for i in range(0, 3) :
  470.                     for j in range(0, 3) :
  471.                         grid_array[i][j].contains = ""
  472.                         tie = []
  473.                         x_wins = False
  474.         if o_wins : #if O won then reset
  475.             x_wins = False
  476.             Turns = False
  477.             screen.blit(OWin, (10, 0))
  478.             notie = False
  479.             gameend = False
  480.             if k[pygame.K_SPACE] :
  481.                 gamestate = 2
  482.                 gameend = True
  483.                 tie = []
  484.                 notie = True
  485.                 o_wins = False
  486.                 for i in range(0, 3) :
  487.                     for j in range(0, 3) :
  488.                         grid_array[i][j].contains = ""
  489.         if notie == True : #if tie than reset
  490.             if len(tie) >= 9 :
  491.                 screen.blit(tietext, (10, 0))
  492.                 if k[pygame.K_SPACE] :
  493.                     gameend = True
  494.                     notie = True
  495.                     gamestate = 2
  496.                     tie = []
  497.                     o_wins = False
  498.                     for i in range(0, 3) :
  499.                         for j in range(0, 3) :
  500.                             grid_array[i][j].contains = ""
  501.  
  502.         screen.blit(grid, (50, 166))
  503.         for grid_line in grid_array :
  504.             for grid_square in grid_line :
  505.                 grid_square.draw(screen)
  506.         pygame.display.update()
  507.         clock.tick(60)
  508. pygame.quit()
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top